defmodule AprsmeWeb.MapLive.Index do
@moduledoc """
LiveView for displaying real-time APRS packets on a map
"""
use AprsmeWeb, :live_view
import AprsmeWeb.TimeHelpers, only: [time_ago_in_words: 1]
import Phoenix.LiveView, only: [connected?: 1, push_event: 3, push_navigate: 2]
alias AprsmeWeb.Endpoint
alias AprsmeWeb.MapLive.MapHelpers
alias AprsmeWeb.MapLive.PacketUtils
alias Phoenix.LiveView.Socket
@default_center %{lat: 39.8283, lng: -98.5795}
@default_zoom 5
@impl true
def mount(_params, _session, socket) do
if connected?(socket) do
# Subscribe to packet updates
Phoenix.PubSub.subscribe(Aprsme.PubSub, "packets")
Phoenix.PubSub.subscribe(Aprsme.PubSub, "bad_packets")
# Schedule periodic cleanup of old packets
Process.send_after(self(), :cleanup_old_packets, 60_000)
end
# Get deployment timestamp from config (set during application startup)
deployed_at = Aprsme.Release.deployed_at()
one_hour_ago = DateTime.add(DateTime.utc_now(), -3600, :second)
socket = assign_defaults(socket, one_hour_ago)
socket = assign(socket, packet_buffer: [], buffer_timer: nil)
socket = assign(socket, all_packets: %{})
if connected?(socket) do
Endpoint.subscribe("aprs_messages")
Phoenix.PubSub.subscribe(Aprsme.PubSub, "postgres:aprsme_packets")
# Defer IP geolocation to avoid blocking initial page load
Process.send_after(self(), :start_geolocation, 2000)
end
{:ok,
assign(socket,
map_ready: false,
map_bounds: nil,
map_center: %{lat: 39.8283, lng: -98.5795},
map_zoom: 4,
visible_packets: %{},
historical_packets: %{},
overlay_callsign: "",
trail_duration: "1",
historical_hours: "1",
packet_age_threshold: one_hour_ago,
slideover_open: true,
deployed_at: deployed_at,
map_page: true
)}
end
@spec assign_defaults(Socket.t(), DateTime.t()) :: Socket.t()
defp assign_defaults(socket, one_hour_ago) do
assign(socket,
packets: [],
page_title: "APRS Map",
visible_packets: %{},
map_bounds: %{
north: 49.0,
south: 24.0,
east: -66.0,
west: -125.0
},
map_center: @default_center,
map_zoom: @default_zoom,
historical_packets: %{},
packet_age_threshold: one_hour_ago,
map_ready: false,
historical_loaded: false,
pending_geolocation: nil,
bounds_update_timer: nil,
pending_bounds: nil,
initial_bounds_loaded: false,
# Overlay controls
overlay_callsign: "",
trail_duration: "1",
historical_hours: "1",
# Slideover state - will be set based on screen size
slideover_open: true
)
end
@impl true
def handle_event("bounds_changed", %{"bounds" => bounds}, socket) do
handle_bounds_update(bounds, socket)
end
@impl true
def handle_event("update_bounds", %{"bounds" => bounds}, socket) do
handle_bounds_update(bounds, socket)
end
@impl true
def handle_event("locate_me", _params, socket) do
# Send JavaScript command to request browser geolocation
{:noreply, push_event(socket, "request_geolocation", %{})}
end
@impl true
def handle_event("set_location", %{"lat" => lat, "lng" => lng}, socket) do
# Update map center and zoom when location is received
# Ensure coordinates are floats
lat_float =
cond do
is_binary(lat) -> String.to_float(lat)
is_integer(lat) -> lat / 1.0
true -> lat
end
lng_float =
cond do
is_binary(lng) -> String.to_float(lng)
is_integer(lng) -> lng / 1.0
true -> lng
end
socket =
socket
|> assign(map_center: %{lat: lat_float, lng: lng_float}, map_zoom: 12)
|> push_event("zoom_to_location", %{lat: lat_float, lng: lng_float, zoom: 12})
{:noreply, socket}
end
@impl true
def handle_event("clear_and_reload_markers", _params, socket) do
# Only filter the current visible_packets, do not re-query the database
filtered_packets =
socket.assigns.visible_packets
|> Enum.filter(fn {_callsign, packet} ->
within_bounds?(packet, socket.assigns.map_bounds) &&
packet_within_time_threshold?(packet, socket.assigns.packet_age_threshold)
end)
|> Map.new()
locale = Map.get(socket.assigns, :locale, "en")
visible_packets_list =
filtered_packets
|> Enum.map(fn {_callsign, packet} -> PacketUtils.build_packet_data(packet, false, locale) end)
|> Enum.filter(& &1)
socket = assign(socket, visible_packets: filtered_packets)
socket =
if Enum.any?(visible_packets_list) do
push_event(socket, "add_markers", %{markers: visible_packets_list})
else
socket
end
{:noreply, socket}
end
@impl true
def handle_event("map_ready", _params, socket) do
socket = assign(socket, map_ready: true)
# Load historical packets with a small delay to ensure map is fully ready
Process.send_after(self(), :reload_historical_packets, 100)
# If we have pending geolocation, zoom to it now
socket =
if socket.assigns.pending_geolocation do
%{lat: lat, lng: lng} = socket.assigns.pending_geolocation
push_event(socket, "zoom_to_location", %{lat: lat, lng: lng, zoom: 12})
else
socket
end
{:noreply, socket}
end
@impl true
def handle_event("marker_clicked", _params, socket) do
{:noreply, socket}
end
@impl true
def handle_event("update_callsign", %{"callsign" => callsign}, socket) do
{:noreply, assign(socket, overlay_callsign: callsign)}
end
@impl true
def handle_event("update_trail_duration", %{"trail_duration" => duration}, socket) do
# Convert duration string to hours and calculate new threshold
hours = String.to_integer(duration)
new_threshold = DateTime.add(DateTime.utc_now(), -hours * 3600, :second)
socket = assign(socket, trail_duration: duration, packet_age_threshold: new_threshold)
# Trigger cleanup to remove packets that are now outside the new duration
send(self(), :cleanup_old_packets)
{:noreply, socket}
end
@impl true
def handle_event("update_historical_hours", %{"historical_hours" => hours}, socket) do
socket = assign(socket, historical_hours: hours)
# Trigger a reload of historical packets with the new time range
if socket.assigns.map_ready do
send(self(), :reload_historical_packets)
end
{:noreply, socket}
end
@impl true
def handle_event("search_callsign", %{"callsign" => callsign}, socket) do
trimmed_callsign = callsign |> String.trim() |> String.upcase()
if trimmed_callsign == "" do
{:noreply, socket}
else
# Navigate to the callsign-specific route
{:noreply, push_navigate(socket, to: "/#{trimmed_callsign}")}
end
end
@impl true
def handle_event("toggle_slideover", _params, socket) do
{:noreply, assign(socket, slideover_open: !socket.assigns.slideover_open)}
end
@impl true
def handle_event("set_slideover_state", %{"open" => open}, socket) do
{:noreply, assign(socket, slideover_open: open)}
end
@impl true
def handle_event("geolocation_error", %{"error" => _error}, socket) do
# Handle geolocation errors gracefully - just continue without geolocation
{:noreply, socket}
end
@impl true
def handle_event("request_geolocation", _params, socket) do
# This event is handled by the JavaScript hook
{:noreply, socket}
end
@impl true
def handle_event("get_assigns", _params, socket) do
send(self(), {:test_assigns, socket.assigns})
{:noreply, socket}
end
@impl true
def handle_info({:process_bounds_update, map_bounds}, socket), do: handle_info_process_bounds_update(map_bounds, socket)
def handle_info({:delayed_zoom, %{lat: lat, lng: lng}}, socket), do: handle_info_delayed_zoom(lat, lng, socket)
def handle_info({:ip_location, %{lat: lat, lng: lng}}, socket), do: handle_info_ip_location(lat, lng, socket)
def handle_info(:initialize_replay, socket), do: handle_info_initialize_replay(socket)
def handle_info(:cleanup_old_packets, socket), do: handle_cleanup_old_packets(socket)
def handle_info(:reload_historical_packets, socket), do: handle_reload_historical_packets(socket)
def handle_info({:postgres_packet, packet}, socket), do: handle_info_postgres_packet(packet, socket)
def handle_info(:start_geolocation, socket), do: handle_info_start_geolocation(socket)
def handle_info(%Phoenix.Socket.Broadcast{topic: "aprs_messages", event: "packet", payload: packet}, socket),
do: handle_info({:postgres_packet, packet}, socket)
# Private handler functions for each message type
defp handle_info_process_bounds_update(map_bounds, socket) do
if !socket.assigns.initial_bounds_loaded or
not compare_bounds(map_bounds, socket.assigns.map_bounds) do
socket = process_bounds_update(map_bounds, socket)
socket = assign(socket, initial_bounds_loaded: true)
{:noreply, socket}
else
{:noreply, socket}
end
end
defp handle_info_delayed_zoom(lat, lng, socket) do
socket = push_event(socket, "zoom_to_location", %{lat: lat, lng: lng, zoom: 12})
{:noreply, socket}
end
defp handle_info_ip_location(lat, lng, socket) do
lat_float =
cond do
is_binary(lat) -> String.to_float(lat)
is_integer(lat) -> lat / 1.0
true -> lat
end
lng_float =
cond do
is_binary(lng) -> String.to_float(lng)
is_integer(lng) -> lng / 1.0
true -> lng
end
# Schedule a delayed zoom to give the user a moment to see the map
Process.send_after(self(), {:delayed_zoom, %{lat: lat_float, lng: lng_float}}, 500)
# We can still optimistically set the center and zoom
socket = assign(socket, map_center: %{lat: lat_float, lng: lng_float}, map_zoom: 12)
{:noreply, socket}
end
defp handle_info_initialize_replay(socket) do
if not socket.assigns.historical_loaded and socket.assigns.map_ready do
# Use default bounds if map_bounds is not available yet
map_bounds =
socket.assigns.map_bounds ||
%{
north: 90.0,
south: -90.0,
east: 180.0,
west: -180.0
}
socket = assign(socket, map_bounds: map_bounds)
# Use optimized query for initial load
socket = load_historical_packets_for_bounds_optimized(socket, map_bounds)
{:noreply, socket}
else
{:noreply, socket}
end
end
defp handle_info_postgres_packet(packet, socket) do
{lat, lon, _data_extended} = MapHelpers.get_coordinates(packet)
callsign_key = get_callsign_key(packet)
# Update all_packets
all_packets = Map.put(socket.assigns.all_packets, callsign_key, packet)
socket = assign(socket, all_packets: all_packets)
# Handle packet visibility logic
handle_packet_visibility(packet, lat, lon, callsign_key, socket)
end
defp get_callsign_key(packet) do
if Map.has_key?(packet, "id"),
do: to_string(packet["id"]),
else: System.unique_integer([:positive])
end
defp handle_packet_visibility(packet, lat, lon, callsign_key, socket) do
cond do
should_remove_marker?(lat, lon, callsign_key, socket) ->
remove_marker_from_map(callsign_key, socket)
should_add_marker?(lat, lon, callsign_key, socket) ->
handle_valid_postgres_packet(packet, lat, lon, socket)
true ->
{:noreply, socket}
end
end
defp should_remove_marker?(lat, lon, callsign_key, socket) do
!is_nil(lat) and !is_nil(lon) and
Map.has_key?(socket.assigns.visible_packets, callsign_key) and
not MapHelpers.within_bounds?(%{lat: lat, lon: lon}, socket.assigns.map_bounds)
end
defp should_add_marker?(lat, lon, callsign_key, socket) do
!is_nil(lat) and !is_nil(lon) and
not Map.has_key?(socket.assigns.visible_packets, callsign_key) and
MapHelpers.within_bounds?(%{lat: lat, lon: lon}, socket.assigns.map_bounds)
end
defp remove_marker_from_map(callsign_key, socket) do
socket = push_event(socket, "remove_marker", %{id: callsign_key})
new_visible_packets = Map.delete(socket.assigns.visible_packets, callsign_key)
{:noreply, assign(socket, visible_packets: new_visible_packets)}
end
defp handle_valid_postgres_packet(packet, _lat, _lon, socket) do
# Add the packet to visible_packets and push a marker immediately
callsign_key =
if Map.has_key?(packet, "id"),
do: to_string(packet["id"]),
else: System.unique_integer([:positive])
new_visible_packets = Map.put(socket.assigns.visible_packets, callsign_key, packet)
# Live packets are always the most recent for their callsign
locale = Map.get(socket.assigns, :locale, "en")
marker_data = PacketUtils.build_packet_data(packet, true, locale)
socket =
if marker_data do
push_event(socket, "new_packet", marker_data)
else
socket
end
{:noreply, assign(socket, visible_packets: new_visible_packets)}
end
defp handle_info_start_geolocation(socket) do
if geolocation_enabled?() do
ip_for_geolocation =
if Application.get_env(:aprsme, AprsmeWeb.Endpoint)[:code_reloader] do
# For testing geolocation in dev environment, use a public IP address.
# This will be geolocated to Mountain View, CA.
"8.8.8.8"
else
extract_ip(socket)
end
if valid_ip_for_geolocation?(ip_for_geolocation) do
start_geolocation_task(ip_for_geolocation)
end
end
{:noreply, socket}
end
defp geolocation_enabled? do
Application.get_env(:aprsme, :disable_aprs_connection, false) != true
end
defp extract_ip(socket) do
case socket.private[:connect_info][:peer_data][:address] do
{a, b, c, d} -> "#{a}.#{b}.#{c}.#{d}"
{a, b, c, d, e, f, g, h} -> "#{a}:#{b}:#{c}:#{d}:#{e}:#{f}:#{g}:#{h}"
_ -> nil
end
end
defp valid_ip_for_geolocation?(ip) do
ip && !String.starts_with?(ip, "127.") && !String.starts_with?(ip, "::1")
end
defp start_geolocation_task(ip) do
Task.start(fn ->
try do
get_ip_location(ip)
rescue
_error ->
send(self(), {:ip_location, @default_center})
end
end)
end
# Handle replaying the next historical packet
@impl true
def render(assigns) do
~H"""
"""
end
# Clean up expired markers from visible_packets and client, but do not re-query the DB
defp handle_cleanup_old_packets(socket) do
# Schedule next cleanup
Process.send_after(self(), :cleanup_old_packets, 60_000)
# Use the current packet_age_threshold instead of hardcoded one hour
threshold = socket.assigns.packet_age_threshold
# Remove expired packets from visible_packets
expired_keys =
socket.assigns.visible_packets
|> Enum.filter(fn {_key, packet} ->
not packet_within_time_threshold?(packet, threshold)
end)
|> Enum.map(fn {key, _} -> key end)
# Only update the client if there are expired markers
socket =
if expired_keys == [] do
socket
else
Enum.reduce(expired_keys, socket, fn key, acc ->
push_event(acc, "remove_marker", %{id: key})
end)
end
# Use Map.drop/2 for better performance
updated_visible_packets = Map.drop(socket.assigns.visible_packets, expired_keys)
{:noreply, assign(socket, visible_packets: updated_visible_packets)}
end
defp handle_reload_historical_packets(socket) do
if socket.assigns.map_ready and socket.assigns.map_bounds do
# Clear existing historical packets
socket = push_event(socket, "clear_historical_packets", %{})
# Use optimized loading for better performance
socket = load_historical_packets_for_bounds_optimized(socket, socket.assigns.map_bounds)
{:noreply, socket}
else
{:noreply, socket}
end
end
# Check if a packet is within the time threshold (not too old)
@spec packet_within_time_threshold?(struct(), any()) :: boolean()
defp packet_within_time_threshold?(packet, threshold) do
case packet do
%{received_at: received_at} when not is_nil(received_at) ->
threshold_dt = convert_threshold_to_datetime(threshold)
DateTime.compare(received_at, threshold_dt) in [:gt, :eq]
_ ->
# If no timestamp, treat as current
true
end
end
defp convert_threshold_to_datetime(threshold) do
cond do
is_integer(threshold) ->
# Assume seconds since epoch
DateTime.from_unix!(threshold)
is_binary(threshold) ->
case DateTime.from_iso8601(threshold) do
{:ok, dt, _} -> dt
_ -> DateTime.utc_now()
end
match?(%DateTime{}, threshold) ->
threshold
true ->
DateTime.utc_now()
end
end
# Helper functions
# Fetch historical packets from the database
defp process_historical_packets(socket, historical_packets) do
socket = push_event(socket, "clear_historical_packets", %{})
packet_data_list = build_packet_data_list(historical_packets)
if Enum.any?(packet_data_list) do
push_event(socket, "add_historical_packets", %{packets: packet_data_list})
else
socket
end
end
defp build_packet_data_list(historical_packets) do
historical_packets
|> Enum.group_by(&PacketUtils.generate_callsign/1)
|> Enum.flat_map(&process_callsign_packets/1)
end
defp process_callsign_packets({callsign, packets}) do
sorted_packets = sort_packets_by_inserted_at(packets)
unique_position_packets = filter_unique_positions(sorted_packets)
unique_position_packets
|> Enum.with_index()
|> Enum.map(&build_packet_data_with_index(&1, callsign))
|> Enum.filter(& &1)
end
defp sort_packets_by_inserted_at(packets) do
Enum.sort_by(
packets,
fn packet ->
case packet.inserted_at do
%NaiveDateTime{} = naive_dt -> DateTime.from_naive!(naive_dt, "Etc/UTC")
%DateTime{} = dt -> dt
_other -> DateTime.utc_now()
end
end,
{:desc, DateTime}
)
end
defp build_packet_data_with_index({packet, index}, callsign) do
# The first packet (index 0) is the most recent for this callsign
# Only show as red dot if it's not the most recent position
is_most_recent = index == 0
# Note: We don't have access to locale here, so we'll use default "en"
packet_data = PacketUtils.build_packet_data(packet, is_most_recent, "en")
if packet_data do
packet_data
|> Map.put(:callsign, callsign)
|> Map.put(:historical, true)
end
end
defp filter_unique_positions(packets) do
packets
|> Enum.reduce([], fn packet, acc ->
add_if_unique_position(packet, acc)
end)
|> Enum.reverse()
end
defp add_if_unique_position(packet, []), do: if_position_present(packet, [])
defp add_if_unique_position(packet, [last_packet | _] = acc), do: if_position_changed(packet, last_packet, acc)
defp if_position_present(packet, acc) do
{lat, lon, _} = MapHelpers.get_coordinates(packet)
if lat && lon, do: [packet | acc], else: acc
end
defp if_position_changed(packet, last_packet, acc) do
{lat, lon, _} = MapHelpers.get_coordinates(packet)
if lat && lon do
if position_changed?(packet, last_packet), do: [packet | acc], else: acc
else
acc
end
end
# Check if position changed significantly between two packets (more than ~1 meter)
@spec position_changed?(struct(), struct()) :: boolean()
defp position_changed?(packet1, packet2) do
{lat1, lng1, _} = MapHelpers.get_coordinates(packet1)
{lat2, lng2, _} = MapHelpers.get_coordinates(packet2)
abs(lat1 - lat2) > 0.0001 || abs(lng1 - lng2) > 0.0001
end
# Fetch historical packets from the database
@spec fetch_historical_packets(list(), DateTime.t(), DateTime.t()) :: [struct()]
defp fetch_historical_packets(bounds, start_time, end_time) do
effective_start_time = start_time
# Use the Packets context to retrieve historical packets
packets_params = %{
bounds: bounds,
start_time: effective_start_time,
end_time: end_time,
with_position: true,
# Reasonable limit to prevent overwhelming the client
limit: 1000
}
# Call the database through the Packets context
packets_module = Application.get_env(:aprsme, :packets_module, Aprsme.Packets)
packets = packets_module.get_packets_for_replay(packets_params)
# Sort packets by received_at timestamp to ensure chronological replay
Enum.sort_by(packets, & &1.received_at)
end
@spec load_historical_packets_for_bounds(Socket.t(), map()) :: Socket.t()
defp load_historical_packets_for_bounds(socket, map_bounds) do
now = DateTime.utc_now()
historical_hours = String.to_integer(socket.assigns.historical_hours)
start_time = DateTime.add(now, -historical_hours * 3600, :second)
bounds = [
map_bounds.west,
map_bounds.south,
map_bounds.east,
map_bounds.north
]
historical_packets = fetch_historical_packets(bounds, start_time, now)
if Enum.empty?(historical_packets) do
assign(socket, historical_loaded: true)
else
process_historical_packets(socket, historical_packets)
end
end
@spec load_historical_packets_for_bounds_optimized(Socket.t(), map()) :: Socket.t()
defp load_historical_packets_for_bounds_optimized(socket, map_bounds) do
bounds = [
map_bounds.west,
map_bounds.south,
map_bounds.east,
map_bounds.north
]
# Use the optimized query for initial load with smaller limit for faster loading
packets_module = Application.get_env(:aprsme, :packets_module, Aprsme.Packets)
historical_packets =
packets_module.get_recent_packets_optimized(%{
bounds: bounds,
# Reduced limit for faster initial load
limit: 200
})
if Enum.empty?(historical_packets) do
assign(socket, historical_loaded: true)
else
process_historical_packets(socket, historical_packets)
end
end
@spec within_bounds?(map() | struct(), map()) :: boolean()
defp within_bounds?(packet, bounds) do
{lat, lon, _data_extended} = MapHelpers.get_coordinates(packet)
# Basic validation
if is_nil(lat) or is_nil(lon) do
false
else
# Check latitude bounds (straightforward)
lat_in_bounds = lat >= bounds.south && lat <= bounds.north
# Check longitude bounds (handle potential wrapping)
lng_in_bounds =
if bounds.west <= bounds.east do
# Normal case: bounds don't cross antimeridian
lon >= bounds.west && lon <= bounds.east
else
# Bounds cross antimeridian (e.g., west=170, east=-170)
lon >= bounds.west || lon <= bounds.east
end
lat_in_bounds && lng_in_bounds
end
end
# Get location from IP using ip-api.com
@spec get_ip_location(String.t() | nil) :: {float(), float()} | nil
defp get_ip_location(nil), do: nil
defp get_ip_location(ip) do
# Asynchronously fetch IP location
case Req.get("https://ip-api.com/json/#{ip}") do
{:ok, %Req.Response{status: 200, body: body}} -> handle_ip_api_response(body)
{:ok, _response} -> send_default_ip_location()
{:error, %{reason: :timeout}} -> send_default_ip_location()
{:error, _error} -> send_default_ip_location()
end
end
defp handle_ip_api_response(body) do
case Jason.decode(body) do
{:ok, %{"status" => "success", "lat" => lat, "lon" => lng}}
when is_number(lat) and is_number(lng) ->
if lat >= -90 and lat <= 90 and lng >= -180 and lng <= 180 do
lat_float = lat / 1.0
lng_float = lng / 1.0
send(self(), {:ip_location, %{lat: lat_float, lng: lng_float}})
else
send_default_ip_location()
end
{:ok, _} ->
send_default_ip_location()
{:error, _decode_error} ->
send_default_ip_location()
end
end
defp send_default_ip_location, do: send(self(), {:ip_location, @default_center})
@impl true
def terminate(_reason, socket) do
if socket.assigns.buffer_timer, do: Process.cancel_timer(socket.assigns.buffer_timer)
# Clean up any pending bounds update timer
if socket.assigns[:bounds_update_timer] do
Process.cancel_timer(socket.assigns.bounds_update_timer)
end
:ok
end
# Add a helper for robust bounds comparison
defp compare_bounds(b1, b2) do
# Handle nil bounds
cond do
is_nil(b1) and is_nil(b2) -> true
is_nil(b1) or is_nil(b2) -> false
true -> compare_bounds_maps(b1, b2)
end
end
defp compare_bounds_maps(b1, b2) do
round4 = fn x ->
case x do
n when is_float(n) -> Float.round(n, 4)
n when is_integer(n) -> n * 1.0
_ -> x
end
end
Enum.all?([:north, :south, :east, :west], fn key ->
round4.(Map.get(b1, key)) == round4.(Map.get(b2, key))
end)
end
# --- Private bounds update helpers ---
@spec handle_bounds_update(map(), Socket.t()) :: {:noreply, Socket.t()}
defp handle_bounds_update(bounds, socket) do
# Update the map bounds from the client, converting to atom keys
map_bounds = %{
north: bounds["north"],
south: bounds["south"],
east: bounds["east"],
west: bounds["west"]
}
# Validate bounds to prevent invalid coordinates
if valid_bounds?(map_bounds) do
handle_valid_bounds_update(map_bounds, socket)
else
# Invalid bounds, skip update
{:noreply, socket}
end
end
defp valid_bounds?(map_bounds) do
map_bounds.north <= 90 and map_bounds.south >= -90 and map_bounds.north > map_bounds.south
end
defp handle_valid_bounds_update(map_bounds, socket) do
# Only schedule a bounds update if the bounds have actually changed (with rounding)
if compare_bounds(map_bounds, socket.assigns.map_bounds) do
{:noreply, socket}
else
schedule_bounds_update(map_bounds, socket)
end
end
defp schedule_bounds_update(map_bounds, socket) do
if socket.assigns[:bounds_update_timer] do
Process.cancel_timer(socket.assigns.bounds_update_timer)
end
timer_ref = Process.send_after(self(), {:process_bounds_update, map_bounds}, 250)
socket = assign(socket, bounds_update_timer: timer_ref, pending_bounds: map_bounds)
{:noreply, socket}
end
@spec process_bounds_update(map(), Socket.t()) :: Socket.t()
defp process_bounds_update(map_bounds, socket) do
# Remove out-of-bounds packets and markers immediately
new_visible_packets =
socket.assigns.visible_packets
|> Enum.filter(fn {_k, packet} -> within_bounds?(packet, map_bounds) end)
|> Map.new()
packets_to_remove =
socket.assigns.visible_packets
|> Enum.reject(fn {_k, packet} -> within_bounds?(packet, map_bounds) end)
|> Enum.map(fn {k, _} -> k end)
# Remove markers for out-of-bounds packets
socket =
if packets_to_remove == [] do
socket
else
Enum.reduce(packets_to_remove, socket, fn k, acc ->
push_event(acc, "remove_marker", %{id: k})
end)
end
# Remove only out-of-bounds historical packets instead of clearing all
socket = push_event(socket, "filter_markers_by_bounds", %{bounds: map_bounds})
# Load additional historical packets for the new bounds if needed
socket = load_historical_packets_for_bounds(socket, map_bounds)
# Update map bounds and visible packets
assign(socket, map_bounds: map_bounds, visible_packets: new_visible_packets)
end
end