In `@Ginger/Ginger/ApplicationModelsLib/POMModels/PomAllElementsPage.xaml.cs`:
- Around line 274-306: Change the exception logging level from DEBUG to ERROR in
the catch blocks within PomAllElementsPage.xaml.cs: update the Reporter.ToLog
calls that currently log exSync, exDriver, and exFallback (the catches around
GetElementAtPoint/Appium live-spy and the WinExplorer
GetControlFromMousePosition fallback) to use eLogLevel.ERROR so failures in the
Appium live-spy path and the WinExplorer fallback (involving
mWinExplorer.GetControlFromMousePosition, LearnElementInfoDetails, etc.) are
logged as errors.
- Around line 270-272: The dispatcher thread is being synchronously blocked by
Task.Run(...).GetAwaiter().GetResult() when calling
appiumDriver.GetElementAtPoint; make the caller async and await the operation
instead (e.g., mark the LiveSpy/tick handler method in
PomAllElementsPage.xaml.cs async and replace the blocking call with await
Task.Run(() => appiumDriver.GetElementAtPoint(p.x, p.y)) or, if the driver
exposes an async API, await that directly), then set foundElement after the
await and call Reporter.ToLog as before so the UI thread remains responsive.
- Around line 256-266: The current catch sets p = (0,0) which can be mistaken
for valid coordinates; change p to a nullable or sentinel value and skip the
element lookup when coords are unknown: replace the local (int x,int y) p with a
nullable tuple (e.g. (int x,int y)? p) or a boolean flag, set p = null (or
flag=false) in the catch block for deviceWindow.GetMousePositionOnDevice(), and
update the subsequent check (the if that currently tests p.x >= 0 && p.y >= 0)
to first ensure p has a value before accessing p.Value.x/p.Value.y (or check the
flag), thereby avoiding treating (0,0) as valid when position retrieval fails.

In `@Ginger/Ginger/AutomatePageLib/AddActionMenu/LiveSpy/LiveSpyPage.xaml.cs`:
- Around line 268-279: LearnElementInfoDetails returns an ElementInfo that may
be an enriched instance; update the code to capture and use that return value
instead of ignoring it by assigning the result back to mSpyElement before
calling mWindowExplorerDriver.UpdateElementInfoFields; keep the existing
try/catch around UpdateElementInfoFields (which takes mSpyElement) so the
enriched element is used for field updates and highlighting.

In
`@Ginger/Ginger/AutomatePageLib/AddActionMenu/WindowExplorer/Common/WindowExplorerPage.xaml.cs`:
- Around line 1489-1622: DrawElementRectangleAsync currently always invokes
mWindowExplorerDriver.HighLightElement(... locateElementByItLocators: true)
which can re-select a different element and override an exact selection; add a
boolean parameter highlightInApp (default true) to DrawElementRectangleAsync,
skip the driver.HighLightElement call when highlightInApp is false, and update
HighlightSelectedElement to call DrawElementRectangleAsync(inspectElementInfo,
highlightInApp: false) so the exact element highlight is preserved; reference
the DrawElementRectangleAsync method, the HighlightSelectedElement caller, and
the mWindowExplorerDriver.HighLightElement invocation when making the change.

In `@Ginger/Ginger/Drivers/DriversConfigsEditPages/AppiumDriverEditPage.xaml.cs`:
- Around line 591-609: The fire-and-forget Task.Run around applying runtime
config (mAgent?.AgentOperations -> GingerCore.AgentOperations ops) hides
failures and can cause races; replace it with an awaited/trackable async flow
that reports status to the UI: perform ops.SetDriverConfiguration() and
ops.WaitForAgentToBeReady() in an async method (or return the Task) and await it
(or store and observe the Task) so exceptions surface to the caller, update
Reporter.ToLog and propagate success/failure to the UI (e.g., status indicator
or message box) so the user is notified if the configuration application fails
or is still in progress; ensure you reference mAgent.AgentOperations /
GingerCore.AgentOperations / ops.SetDriverConfiguration /
ops.WaitForAgentToBeReady when locating the code to change.
- Around line 754-758: The empty catch in AppiumDriverEditPage.xaml.cs silently
swallows initialization errors; change the bare catch to catch(Exception e) and
log the full error via Reporter.ToLog(eLogLevel.ERROR, ...) including a concise
context message (e.g., "Error loading Appium driver edit controls") plus
e.Message and e.StackTrace so initialization failures are recorded; update the
catch block that follows the try which loads the page controls in the
AppiumDriverEditPage class accordingly.

In `@Ginger/Ginger/Drivers/DriversWindows/MobileDriverWindow.xaml.cs`:
- Around line 152-369: The TV highlights are being auto-cleared because the
auto-clear path and any external refresh logic ignore the mKeepHighlightTv flag;
update HighlightElementOnDevice to avoid starting the 5s DispatcherTimer when
mKeepHighlightTv is set (or skip scheduling any auto-clear for
eDevicePlatformType.Android TV path) and ensure any external refresh/cleanup
code that checks mLastHighlightTime respects mKeepHighlightTv before clearing;
also reset mKeepHighlightTv = false inside ClearHighlightedElementOnDevice after
removing TV highlight so state doesn’t drift (refer to mKeepHighlightTv,
mLastHighlightTime, HighlightElementOnDevice, ClearHighlightedElementOnDevice
and the timer/refresh code that clears highlights).
- Around line 478-489: In CurrentMousePosToSpy, guard against a null screenshot
source by calling SafeGetDeviceImageSource and returning early if it is null;
use the safe image returned instead of accessing xDeviceScreenshotImage.Source
directly when computing sizes for ((DriverBase)mDriver).GetPointOnAppWindow, and
keep the existing Dispatcher.Invoke for mousePos and pointOnAppScreen but pass
safeImage.Width/Height (and ActualWidth/ActualHeight from
xDeviceScreenshotImage) to avoid dereferencing a null Source.

In `@Ginger/Ginger/UserControlsLib/ImageMakerLib/ImageMakerControl.xaml.cs`:
- Around line 934-936: The tooltip text for the Mobile image type uses
inconsistent casing ("Mobile/Tv"); update the call in the eImageType.Mobile case
where SetAsFontAwesomeIcon is invoked with
EFontAwesomeIcon.Solid_MobileScreenButton to use "Mobile/TV" instead so it
matches the rest of the UI casing and style.
- Around line 1324-1340: The fallback render currently uses the incoming width
directly which yields 1×1 bitmaps when callers pass 0; fix by measuring the
control with double.PositiveInfinity when width == 0 (call IM.Measure(new
Size(double.PositiveInfinity, double.PositiveInfinity))), then use
IM.DesiredSize to set desiredWidth and desiredHeight (falling back to the
provided width when non-zero), proceed with IM.Arrange/IM.UpdateLayout, and
compute pixelWidth/pixelHeight from the resolved desiredWidth/desiredHeight
before creating the RenderTargetBitmap and calling rtb.Render(IM).

In `@Ginger/Ginger/UserControlsLib/ucGridView/ucGrid.xaml.cs`:
- Around line 2164-2175: Replace the magic number 27.0 in the Convert method
with a well-named constant to clarify intent: declare a private const double
(e.g., MultipleScreenImageWidth) near the ucGrid.xaml.cs class and use that
constant instead of the literal when computing desiredWidth for
Amdocs.Ginger.Common.Enums.eImageType.MultipleScreen; keep the existing type
check and the call to ImageMakerControl.GetImageSource(imageType, null, 0, null,
desiredWidth) unchanged.

In `@Ginger/Ginger/UserControlsLib/UCListView/UcListViewItem.xaml.cs`:
- Around line 54-85: The empty catch in ApplyTitleAndTooltipForAct silently
swallows all exceptions; update it to catch Exception ex and call
Reporter.ToLog(Reporter.eLogLevel.Debug, $"ApplyTitleAndTooltipForAct failed",
ex) (or equivalent overload) so the exception and context are logged at DEBUG
level while still preventing the exception from bubbling, keeping the existing
behavior of not impacting list rendering.
- Around line 156-166: Consolidate the redundant casts in OnItemPropertyChanged
by casting the DependencyObject d once to UcListViewItem (e.g., reuse uli) and
use that single variable for both setting Item and calling
ApplyTitleAndTooltipForAct; replace the separate "if (d is UcListViewItem
control && e.NewValue != null) { control.Item = ... }" with a null-check on uli
and e.NewValue, assign uli.Item when appropriate, then call
uli.ApplyTitleAndTooltipForAct(uli.Item), removing the extra 'control' variable
and duplicate cast.

In `@Ginger/GingerCoreCommon/Drivers/CoreDrivers/Mobile/MobileDriverCommon.cs`:
- Around line 21-35: Rename the enum member eDeviceSource.AndroidTV to AndroidTv
to match the project's PascalCase convention and the existing
eDevicePlatformType.AndroidTv usage; update the declaration inside enum
eDeviceSource and search for all usages of eDeviceSource.AndroidTV (e.g., places
that set or compare device source) and replace them with eDeviceSource.AndroidTv
so references (such as in GenericAppiumDriver, AppiumDriverEditPage.xaml.cs,
MobileDriverWindow.xaml.cs, eImageType.cs) compile and remain consistent.

In `@Ginger/GingerCoreCommon/Repository/PlatformsLib/ApplicationPlatform.cs`:
- Around line 108-143: The setter block for Platform (handling string inputs) is
emitting duplicate notifications and uses OrdinalIgnoreCase; update the logic
that sets this.Platform inside the Enum.TryParse<ePlatformType> and the
description-matching loop to only call OnPropertyChanged once per change (for
nameof(Platform) and nameof(PlatformDescription)) and remove any redundant
calls, and change comparisons that use StringComparison.OrdinalIgnoreCase to
StringComparison.CurrentCultureIgnoreCase when comparing the incoming value to
the enum description (the code using
Amdocs.Ginger.Common.GeneralLib.General.GetEnumValueDescription and the initial
Enum.TryParse check should use culture-aware comparisons where applicable).

In `@Ginger/GingerCoreCommon/Run/ApplicationAgent.cs`:
- Around line 113-120: Wrap the call to
Amdocs.Ginger.Common.GeneralLib.General.GetEnumValueDescription in a safe guard
so exceptions cannot bubble into UI binding: in ApplicationAgent.cs around the
property that reads AppPlatform.Platform, catch any Exception when calling
GetEnumValueDescription (both the AppPlatform branch and the ePlatformType.NA
fallback), and return a safe string fallback (e.g., the enum name or "Unknown")
on error; reference the AppPlatform property, the GetEnumValueDescription
method, and ePlatformType.NA so you update both return paths to use the guarded
call.

In `@Ginger/GingerCoreNET/ActionsLib/UI/Mobile/ActMobileDevice.cs`:
- Around line 128-142: The PostDeserialization method in ActMobileDevice
currently swallows all exceptions in its catch block; update it to catch
Exception (e.g., catch (Exception ex)) and call Reporter.ToLog(eLogLevel.ERROR,
$"PostDeserialization failed in ActMobileDevice: {ex}") so errors are recorded;
keep the defensive behavior (do not rethrow) but ensure the exception details
are logged for debugging.
- Around line 45-75: Replace the inconsistent "Tv" casing with "TV" in all
user-facing string properties and methods: update ActionDescription,
ActionUserDescription, ToString(), and ActionType to use "Mobile/TV Device
Action" (and any occurrences of Mobile/Tv elsewhere in this class) so the
abbreviation is consistently capitalized; ensure you only change the string
literals and keep method/property names and behavior intact.
- Around line 37-60: Remove the duplicate Description initialization from the
ActMobileDevice constructor and keep the assignment in DoNewActionSetup;
specifically, delete the constructor's block that sets this.Description from
this.ActionDescription so new-action setup logic lives only in DoNewActionSetup,
and if needed add or ensure a PostDeserialization handler sets Description from
ActionDescription for deserialized instances (referencing ActMobileDevice(),
DoNewActionSetup(), Description, ActionDescription, and PostDeserialization).
- Around line 26-27: Remove the unused using directive by deleting the "using
System.Linq;" line at the top of ActMobileDevice.cs (the file containing the
ActMobileDevice class), leaving only required usings such as "using
System.Collections.Generic;"; after removal, rebuild to ensure no LINQ symbols
are needed elsewhere in that file.

In `@Ginger/GingerCoreNET/RunLib/AgentOperations.cs`:
- Around line 387-405: The loop in Agent.DriverConfiguration mutates persisted
DriverConfigParam.Value (and subValue.Value) with evaluated/decrypted
ve.ValueCalculated, which risks persisting secrets and losing original VE
expressions; instead, create a runtime-only representation (e.g., clone
Agent.DriverConfiguration or build a Dictionary/temporary list keyed by
DriverConfigParam.Name) and set evaluated values there for use at runtime,
leaving the original DriverConfigParam and its MultiValues untouched; update the
code around the foreach over Agent.DriverConfiguration (symbols:
DriverConfigParam, MultiValues, Value, ve.Value, ve.ValueCalculated) to populate
and use that local evaluated map/clone rather than assigning back to DCP.Value
or subValue.Value.
- Around line 448-494: The code currently uses Enum.Parse (inside the
UserConfiguredEnumTypeAttribute handling) and int.Parse/Convert.ToBoolean which
can throw and produce misleading logs; replace Enum.Parse with Enum.TryParse
using the enum type from UserConfiguredEnumTypeAttribute (preserving
case-sensitivity as intended) and only call driverProp.SetValue(Driver,
parsedEnum) when TryParse succeeds (log or handle invalid values instead of
relying on exceptions), and similarly use Int32.TryParse for the "Int32" case
and Boolean.TryParse for "Boolean" (fall back to the existing default true
behavior only when parsing fails if that behaviour is desired), updating the
blocks around UserConfiguredEnumTypeAttribute, driverProp.SetValue, Enum.Parse,
int.Parse and Convert.ToBoolean accordingly.

In `@Ginger/Ginger/ApplicationModelsLib/POMModels/PomAllElementsPage.xaml.cs`:
- Line 30: Remove the unused using directive "using System.Linq;" from the top
of PomAllElementsPage.xaml.cs; it is not referenced by any methods or types in
that file (e.g., PomAllElementsPage class) so simply delete that line and run a
quick build to ensure no missing references remain.

In
`@Ginger/GingerCoreNET/Drivers/CoreDrivers/Mobile/Appium/GenericAppiumDriver.cs`:
- Around line 1709-1801: EnsureDeviceBounds currently returns early when
ElementInfo.Properties contains a "bounds" entry or ei.Width/ei.Height > 0,
leaving Width/Height unset for XML-sourced elements; update EnsureDeviceBounds
to, before returning, check Properties for a bounds ControlProperty (Name equals
"bounds", case-insensitive) or separate "x"/"y"/"width"/"height" properties,
parse those values into integers and populate ei.X, ei.Y, ei.Width, ei.Height
(and ensure ControlProperty list exists) so SetRectangleProperties gets correct
size; keep existing parsing logic for "[l,t][r,b]" but also handle "[l,t,r,b]"
and individual numeric attrs, and only return early after filling the missing
fields (use the existing LearnElementInfoDetails fallback and exception handling
unchanged).
- Around line 2167-2212: The Android TV default of 1080x1920 is forcing
portrait; update the logic in GenericAppiumDriver (where ScreenshotWidth,
ScreenshotHeight, DevicePlatformType, customeWidth and customeHeight are
handled) to respect actual TV orientation: if both ScreenshotWidth/Height are
null for eDevicePlatformType.AndroidTv, query the device's real display size or
orientation (e.g., realDisplaySize / GetDeviceScreenSize / ScreenOrientation)
and set customeWidth/customeHeight to the device's native resolution (landscape
1920x1080 when the device reports landscape); if you cannot obtain the real
size, keep both as null (Auto) instead of forcing portrait so
scaling/hit-testing aren’t skewed. Ensure you still log the decision via
Reporter.ToLog.
- Around line 4232-4275: The current Tap handling always calls TapXY((int)x,
(int)y) which will fail on non-touch Android TV devices; add a touch-capability
check (e.g., implement a helper like HasTouchSupport or IsTouchDevice that
queries session/device capabilities for "android.hardware.touchscreen" or uses
ADB/driver capabilities) in GenericAppiumDriver before calling TapXY, and when
touch is absent use a DPAD fallback (implement a method like
PerformDPadTap/SendDPadNavigation that navigates to the target or sends
DPAD_CENTER/DPAD_LEFT/RIGHT/UP/DOWN key events via the Appium
driver/sendKeyEvent) so recordings (IsRecording, GetElementAtMousePosition,
RecordingEvent) remain unchanged but the actual interaction uses DPAD on TV
devices; update the try block to branch: if HasTouchSupport -> TapXY(...) else
-> PerformDPadTap(...) and ensure errors are still logged in the existing catch.

In `@Ginger/GingerCoreNET/Resources/JavaScripts/GingerLiveSpy.js`:
- Around line 205-208: The empty catch in the static init hides errors from
define_GingerLibLiveSpy(); update the catch to capture and surface the error:
catch the exception from define_GingerLibLiveSpy, log it conditionally (e.g.,
console.error or processLogger.error when available) and optionally store it in
a module-scoped variable (e.g., lastDefine_GingerLibLiveSpyError) so callers or
dev tools can inspect it later; modify the block around
define_GingerLibLiveSpy() to implement these minimal changes.
- Around line 137-160: The falsy check in GingerLibLiveSpy.ElementFromPoint
incorrectly treats X or Y equal to 0 as missing; change the guard to explicitly
detect invalid coordinates by testing for NaN/undefined instead of using (!X ||
!Y). Specifically, when using GetXPoint()/GetYPoint() and variables X and Y,
replace the existing falsy check with an explicit condition like isNaN(X) ||
isNaN(Y) or X == null || Y == null so the Android TV fallback to
CurrentFocusedElement only runs when coordinates are actually invalid.
- Around line 107-132: The code contains inconsistent method naming: misspelled
StartEventListner and StartClickEventListner vs correctly spelled
StartFocusEventListener and StartKeyEventListener; because C# drivers
(SeleniumDriver.cs, GingerWebDriver.cs) call the misspelled names, add
correctly‑spelled wrapper/alias functions (e.g., StartEventListener and
StartClickEventListener) that internally call the existing StartEventListner and
StartClickEventListner, and add the reverse alias or deprecation warning on the
old functions (console.warn or comment) to guide migration; also update
GingerHTMLHelper.js to provide the same aliasing for StartEventListnerFrame →
StartEventListenerFrame and add brief in-file comments documenting the
deprecation and required coordination with C# callers.