`` lines."""
lines = [_BLOCK_BEGIN]
- for d in BLOCKLIST:
- lines.append("0.0.0.0 %s" % d)
- lines.append("0.0.0.0 www.%s" % d)
+ for host in blocked_hosts():
+ lines.append("0.0.0.0 %s" % host)
lines.append(_BLOCK_END)
return "\n".join(lines) + "\n"
@@ -176,7 +249,7 @@ def _write_state(instance_dir: str, applied: bool) -> None:
pass
return
data = {"telemetry_block": True,
- "domains": len(BLOCKLIST),
+ "domains": len(blocked_hosts()),
"applied_at": datetime.datetime.now().isoformat(timespec="seconds")}
try:
with open(state, "w", encoding="utf-8") as f:
@@ -223,7 +296,7 @@ def _p(msg: str) -> None:
except OSError as exc:
logger.warning("could not save hosts backup: %s", exc)
new = base + _block_text()
- _p("Writing %d blocked domains into guest hosts..." % len(BLOCKLIST))
+ _p("Writing %d blocked hostnames into guest hosts..." % len(blocked_hosts()))
out = _write_hosts(dev, sysroot, new, env)
written = _dump_hosts(dev, sysroot, env)
if not has_block(written):
@@ -232,7 +305,8 @@ def _p(msg: str) -> None:
if not _es._fsck_ok(dev, env):
raise RuntimeError("e2fsck reported errors after writing hosts")
_write_state(instance_dir, True)
- return ["Blocked %d ad/telemetry domains in the guest hosts file." % len(BLOCKLIST)]
+ return ["Blocked %d ad/tracker hostnames in the guest hosts file."
+ % len(blocked_hosts())]
def remove(instance_dir: str, progress=None) -> list[str]:
diff --git a/tests/test_ad_settings.py b/tests/test_ad_settings.py
new file mode 100644
index 0000000..6940291
--- /dev/null
+++ b/tests/test_ad_settings.py
@@ -0,0 +1,219 @@
+"""Tests for ad_settings: which config keys get turned off, and the toggle.
+
+The fixture below is the real key set observed in bluestacks.conf on
+5.22.250.1015 (BlueStacks 5, Android 13 instance), including the near-misses
+that must NOT be touched -- bst.enable_adb_access (contains "ad"),
+android_google_ad_id (an id, not a switch), the *_preference keys (they control
+whether BlueStacks' own ad toggle is visible), and skipNowggLogin (inverted).
+"""
+import ad_settings as ads
+
+# Verbatim shape of the real config, trimmed to the relevant keys.
+REAL_CONF = '''\
+bst.campaign_hash="5eb05192d5318a59eed61137da00d3e7"
+bst.campaign_name=""
+bst.enable_adb_access="1"
+bst.enable_adb_remote_access="0"
+bst.enable_android_ads_test_app="0"
+bst.enable_auto_upload_recording="1"
+bst.enable_boot_banner="1"
+bst.enable_gamepad_detection="1"
+bst.enable_programmatic_ads="1"
+bst.feature.android_ads_stats="0"
+bst.feature.auto_upload_nowgg_moments="1"
+bst.feature.auto_upload_nowgg_recording="1"
+bst.feature.bluestacksX="1"
+bst.feature.nowbux="1"
+bst.feature.nowgg_cloud_upload_enabled="1"
+bst.feature.nowgg_login_popup="1"
+bst.feature.programmatic_ads="1"
+bst.feature.rooting="1"
+bst.feature.send_internal_notification_stats="1"
+bst.feature.send_notification_stats="0"
+bst.feature.send_nowbux_login_boot_stats="1"
+bst.feature.send_offer_stats="0"
+bst.feature.send_programmatic_ads_boot_stats="1"
+bst.feature.send_programmatic_ads_click_stats="1"
+bst.feature.send_programmatic_ads_fill_stats="0"
+bst.feature.show_boot_banner_preference="1"
+bst.feature.show_gp_ads="1"
+bst.feature.show_programmatic_ads_preference="1"
+bst.feature.skipNowggLogin="1"
+bst.instance.Tiramisu64.ads_app_package="com.uncube.gamevantage"
+bst.instance.Tiramisu64.android_google_ad_id="b11c1080-79be-42f6-99b4-0ae2bdf109ee"
+bst.instance.Tiramisu64.enable_root_access="1"
+bst.instance.Tiramisu64.split_ad_enabled="0"
+bst.nowgg_username=""
+'''
+
+
+def _conf(tmp_path, text=REAL_CONF):
+ p = tmp_path / "bluestacks.conf"
+ p.write_text(text, encoding="utf-8")
+ return str(p)
+
+
+# --- the three safety gates -------------------------------------------------
+
+def test_adb_keys_are_never_managed():
+ """"adb" contains "ad" -- the classic false positive."""
+ assert ads.is_managed("bst.enable_adb_access", "1") is False
+ assert ads.is_managed("bst.enable_adb_remote_access", "0") is False
+
+
+def test_rooting_keys_are_never_managed():
+ assert ads.is_managed("bst.feature.rooting", "1") is False
+ assert ads.is_managed("bst.instance.Foo.enable_root_access", "1") is False
+
+
+def test_preference_keys_are_never_managed():
+ """These control whether the user's own ad toggle is visible in Settings."""
+ assert ads.is_managed("bst.feature.show_programmatic_ads_preference", "1") is False
+ assert ads.is_managed("bst.feature.show_boot_banner_preference", "1") is False
+
+
+def test_inverted_semantics_keys_are_never_managed():
+ """We only ever write "0", so a disable_/skip_ key would be flipped backwards."""
+ assert ads.is_managed("bst.feature.skipNowggLogin", "1") is False
+ assert ads.is_managed("bst.feature.disable_ads", "1") is False
+
+
+def test_non_boolean_values_are_never_managed():
+ """The value gate keeps ids and strings out no matter how they're named."""
+ assert ads.is_managed("bst.instance.X.android_google_ad_id", "b11c1080-79be") is False
+ assert ads.is_managed("bst.instance.X.ads_app_package", "com.uncube.gamevantage") is False
+ assert ads.is_managed("bst.instance.X.ads_display_time", "") is False
+
+
+def test_real_ad_switches_are_managed():
+ for key in ("bst.enable_programmatic_ads",
+ "bst.feature.programmatic_ads",
+ "bst.feature.show_gp_ads",
+ "bst.enable_boot_banner",
+ "bst.feature.nowbux",
+ "bst.feature.bluestacksX",
+ "bst.feature.send_programmatic_ads_boot_stats",
+ "bst.feature.send_internal_notification_stats",
+ "bst.feature.auto_upload_nowgg_moments",
+ "bst.enable_auto_upload_recording"):
+ assert ads.is_managed(key, "1") is True, key
+
+
+def test_a_future_renamed_stats_key_is_still_caught():
+ """The point of pattern discovery: no code change for a new build's keys."""
+ assert ads.is_managed("bst.feature.send_brand_new_ad_stats", "1") is True
+ assert ads.is_managed("bst.feature.programmatic_ads_v2", "1") is True
+
+
+# --- discovery --------------------------------------------------------------
+
+def test_discover_finds_switches_and_excludes_the_near_misses(tmp_path):
+ found = ads.discover(_conf(tmp_path))
+ assert "bst.enable_programmatic_ads" in found
+ assert "bst.feature.send_programmatic_ads_boot_stats" in found
+ # near misses stay out
+ for key in ("bst.enable_adb_access",
+ "bst.feature.rooting",
+ "bst.instance.Tiramisu64.enable_root_access",
+ "bst.feature.skipNowggLogin",
+ "bst.feature.show_programmatic_ads_preference",
+ "bst.instance.Tiramisu64.android_google_ad_id",
+ "bst.instance.Tiramisu64.ads_app_package",
+ "bst.campaign_hash"):
+ assert key not in found, key
+
+
+def test_discover_reports_current_values(tmp_path):
+ found = ads.discover(_conf(tmp_path))
+ assert found["bst.enable_programmatic_ads"] == "1"
+ assert found["bst.feature.send_offer_stats"] == "0" # already off, still managed
+
+
+# --- apply / remove ---------------------------------------------------------
+
+def test_apply_turns_everything_off_and_status_reports_it(tmp_path):
+ conf = _conf(tmp_path)
+ assert ads.status(conf) is None
+ ads.apply(conf)
+ after = ads.discover(conf)
+ assert after and all(v == "0" for v in after.values())
+ st = ads.status(conf)
+ assert st["ads_disabled"] is True
+ assert st["reverted"] == []
+ assert set(st["off"]) == set(after)
+
+
+def test_apply_leaves_unrelated_keys_untouched(tmp_path):
+ conf = _conf(tmp_path)
+ ads.apply(conf)
+ text = open(conf, encoding="utf-8").read()
+ assert 'bst.enable_adb_access="1"' in text
+ assert 'bst.feature.rooting="1"' in text
+ assert 'bst.instance.Tiramisu64.enable_root_access="1"' in text
+ assert 'bst.feature.skipNowggLogin="1"' in text
+ assert 'bst.instance.Tiramisu64.android_google_ad_id="b11c1080-79be-42f6-99b4-0ae2bdf109ee"' in text
+
+
+def test_remove_restores_original_values_exactly(tmp_path):
+ conf = _conf(tmp_path)
+ before = open(conf, encoding="utf-8").read()
+ ads.apply(conf)
+ ads.remove(conf)
+ assert open(conf, encoding="utf-8").read() == before
+ assert ads.status(conf) is None
+
+
+def test_apply_is_idempotent(tmp_path):
+ conf = _conf(tmp_path)
+ ads.apply(conf)
+ once = open(conf, encoding="utf-8").read()
+ ads.apply(conf)
+ assert open(conf, encoding="utf-8").read() == once
+
+
+def test_reapply_after_bluestacks_reverts_a_key_keeps_true_originals(tmp_path):
+ """BlueStacks puts some keys back to "1" on start; re-applying must not
+ record "1" as the original and must not lose the real pre-change value."""
+ conf = _conf(tmp_path)
+ ads.apply(conf)
+ # BlueStacks reverts one of the keys it's known to revert
+ import config_handler
+ config_handler.modify_config_file(conf, "bst.feature.programmatic_ads", "1")
+ st = ads.status(conf)
+ assert st["reverted"] == ["bst.feature.programmatic_ads"]
+
+ ads.apply(conf)
+ assert ads.status(conf)["reverted"] == []
+ # and a full removal still restores the genuine original, not the reverted value
+ ads.remove(conf)
+ text = open(conf, encoding="utf-8").read()
+ assert 'bst.feature.send_offer_stats="0"' in text # was already 0 originally
+ assert 'bst.feature.programmatic_ads="1"' in text # was 1 originally
+
+
+def test_status_flags_switches_a_bluestacks_update_added(tmp_path):
+ conf = _conf(tmp_path)
+ ads.apply(conf)
+ import config_handler
+ config_handler.modify_config_file(conf, "bst.feature.send_shiny_new_stats", "1")
+ st = ads.status(conf)
+ assert st["unmanaged"] == ["bst.feature.send_shiny_new_stats"]
+ # re-applying adopts it
+ ads.apply(conf)
+ st = ads.status(conf)
+ assert st["unmanaged"] == []
+ assert "bst.feature.send_shiny_new_stats" in st["off"]
+
+
+def test_apply_on_a_config_with_no_switches_is_not_an_error(tmp_path):
+ conf = _conf(tmp_path, 'bst.enable_adb_access="1"\nbst.feature.rooting="1"\n')
+ msg = ads.apply(conf)[0]
+ assert "No ad/telemetry switches found" in msg
+ assert ads.status(conf) is None
+
+
+def test_remove_without_apply_is_a_no_op(tmp_path):
+ conf = _conf(tmp_path)
+ before = open(conf, encoding="utf-8").read()
+ ads.remove(conf)
+ assert open(conf, encoding="utf-8").read() == before
diff --git a/tests/test_privacy_page.py b/tests/test_privacy_page.py
index d68b524..a02fd95 100644
--- a/tests/test_privacy_page.py
+++ b/tests/test_privacy_page.py
@@ -52,6 +52,84 @@ def test_busy_disables_visible_button(qtbot):
assert page.unblock_button.isEnabled() is True
+# --- global BlueStacks ad/telemetry switches --------------------------------
+
+_ADS_OFF = {"ads_disabled": True, "keys": 23, "off": ["a"], "reverted": [],
+ "unmanaged": [], "locked": False}
+
+
+def test_ads_on_offers_turn_off_only(qtbot):
+ page = _page(qtbot, {})
+ page.set_ad_status(None, 23)
+ assert page.ads_off_button.isVisibleTo(page) is True
+ assert page.ads_restore_button.isVisibleTo(page) is False
+ assert "are ON" in page.ads_status_label.text()
+ assert "23" in page.ads_status_label.text()
+
+
+def test_ads_off_offers_restore_only(qtbot):
+ page = _page(qtbot, {})
+ page.set_ad_status(_ADS_OFF, 23)
+ assert page.ads_off_button.isVisibleTo(page) is False
+ assert page.ads_restore_button.isVisibleTo(page) is True
+ assert "are OFF" in page.ads_status_label.text()
+
+
+def test_reverted_switches_offer_turn_off_again(qtbot):
+ """BlueStacks puts some keys back on every start; the user needs a re-apply."""
+ page = _page(qtbot, {})
+ page.set_ad_status(dict(_ADS_OFF, reverted=["bst.feature.nowbux"]), 23)
+ assert page.ads_off_button.isVisibleTo(page) is True
+ assert page.ads_restore_button.isVisibleTo(page) is True
+ assert "turned 1 back on" in page.ads_status_label.text()
+
+
+def test_switches_added_by_a_bluestacks_update_offer_reapply(qtbot):
+ page = _page(qtbot, {})
+ page.set_ad_status(dict(_ADS_OFF, unmanaged=["bst.feature.send_new_stats"]), 24)
+ assert page.ads_off_button.isVisibleTo(page) is True
+ assert "added 1 new switch" in page.ads_status_label.text()
+
+
+def test_no_switches_in_this_build_hides_the_control(qtbot):
+ page = _page(qtbot, {})
+ page.set_ad_status(None, 0)
+ assert page.ads_off_button.isVisibleTo(page) is False
+ assert "no switches found" in page.ads_status_label.text()
+
+
+def test_ads_buttons_emit_signals(qtbot):
+ page = _page(qtbot, {})
+ page.set_ad_status(None, 23)
+ with qtbot.waitSignal(page.ads_off_requested, timeout=1000):
+ qtbot.mouseClick(page.ads_off_button, Qt.LeftButton)
+ page.set_ad_status(_ADS_OFF, 23)
+ with qtbot.waitSignal(page.ads_restore_requested, timeout=1000):
+ qtbot.mouseClick(page.ads_restore_button, Qt.LeftButton)
+
+
+def test_lock_checkbox_reflects_state_without_emitting(qtbot):
+ """set_ad_status() syncs the box to reality; only a user click should fire."""
+ page = _page(qtbot, {})
+ fired = []
+ page.ads_lock_toggled.connect(fired.append)
+ page.set_ad_status(dict(_ADS_OFF, locked=True), 23)
+ assert page.ads_lock_check.isChecked() is True
+ assert fired == []
+ page.ads_lock_check.setChecked(False)
+ assert fired == [False]
+
+
+def test_busy_disables_ads_buttons(qtbot):
+ page = _page(qtbot, {})
+ page.set_ad_status(None, 23)
+ assert page.ads_off_button.isEnabled() is True
+ page.set_busy(True)
+ assert page.ads_off_button.isEnabled() is False
+ page.set_busy(False)
+ assert page.ads_off_button.isEnabled() is True
+
+
def test_buttons_emit_signals(qtbot):
page = _page(qtbot, {"A (Normal)": None})
page._radios["A (Normal)"].setChecked(True)
diff --git a/tests/test_telemetry_block.py b/tests/test_telemetry_block.py
index d18bd77..066ed62 100644
--- a/tests/test_telemetry_block.py
+++ b/tests/test_telemetry_block.py
@@ -9,10 +9,36 @@
def test_blocklist_is_nonempty_lowercase_domains():
assert tb.BLOCKLIST
- for d in tb.BLOCKLIST:
+ for d in tb.BLOCKLIST + tb.HOST_BLOCKLIST:
assert d == d.lower() and " " not in d and "/" not in d
- # the ad exchange caught in the live capture is in the list
- assert "rtbhouse.net" in tb.BLOCKLIST
+
+
+def test_dead_rtbhouse_net_entry_is_gone():
+ """It never resolved; the live endpoint is esp.rtbhouse.com.
+
+ Compared by equality rather than ``in``: an entry has to be its own exact
+ hostname, so a substring sitting inside some longer domain cannot satisfy
+ this. (It also keeps CodeQL's incomplete-URL-sanitization rule quiet, which
+ cannot tell tuple membership from a substring check on a URL.)
+ """
+ assert not any(d == "rtbhouse.net" for d in tb.BLOCKLIST)
+ assert any(d == "rtbhouse.com" for d in tb.BLOCKLIST)
+ assert any(h == "esp.rtbhouse.com" for h in tb.HOST_BLOCKLIST)
+
+
+def test_subdomains_are_listed_explicitly_because_hosts_cannot_wildcard():
+ """An apex entry does not cover subdomains, and ad traffic is subdomains."""
+ hosts = tb.blocked_hosts()
+ for fqdn in ("cm.g.doubleclick.net",
+ "pagead2.googlesyndication.com",
+ "api.w.inmobi.com",
+ "esp.rtbhouse.com"):
+ assert fqdn in hosts, fqdn
+
+
+def test_blocked_hosts_has_no_duplicates():
+ hosts = tb.blocked_hosts()
+ assert len(hosts) == len(set(hosts))
def test_block_text_markers_and_null_routes():
@@ -21,6 +47,8 @@ def test_block_text_markers_and_null_routes():
for d in tb.BLOCKLIST:
assert "0.0.0.0 %s" % d in text
assert "0.0.0.0 www.%s" % d in text # www alias too
+ for h in tb.HOST_BLOCKLIST:
+ assert "0.0.0.0 %s" % h in text
assert tb.has_block(text) is True
@@ -32,7 +60,7 @@ def test_strip_block_removes_only_the_marked_section():
assert tb.has_block(stripped) is False
# the user's real hosts entries survive
assert "127.0.0.1\tlocalhost" in stripped
- assert "rtbhouse.net" not in stripped
+ assert "doubleclick.net" not in stripped
def test_apply_is_idempotent_no_double_block():
@@ -53,6 +81,6 @@ def test_state_sidecar_roundtrip(tmp_path):
tb._write_state(str(tmp_path), True)
st = tb.status(str(tmp_path))
assert st["telemetry_block"] is True
- assert st["domains"] == len(tb.BLOCKLIST)
+ assert st["domains"] == len(tb.blocked_hosts())
tb._write_state(str(tmp_path), False)
assert tb.status(str(tmp_path)) is None
diff --git a/views/main_window.py b/views/main_window.py
index 661a57d..a0c34b3 100644
--- a/views/main_window.py
+++ b/views/main_window.py
@@ -196,6 +196,9 @@ def init_ui(self) -> None:
self.magisk_page.install_lsposed_requested.connect(self.magisk_controller.handle_install_lsposed)
self.privacy_page.block_requested.connect(self.privacy_controller.handle_block)
self.privacy_page.unblock_requested.connect(self.privacy_controller.handle_unblock)
+ self.privacy_page.ads_off_requested.connect(self.privacy_controller.handle_ads_off)
+ self.privacy_page.ads_restore_requested.connect(self.privacy_controller.handle_ads_restore)
+ self.privacy_page.ads_lock_toggled.connect(self.privacy_controller.handle_ads_lock)
self.setMinimumWidth(700)
self.setMinimumHeight(480)
@@ -633,7 +636,8 @@ def _action_buttons(self):
self.magisk_page.install_button, self.magisk_page.uninstall_button,
self.magisk_page.manager_button, self.magisk_page.remove_manager_button,
self.magisk_page.rezygisk_button, self.magisk_page.lsposed_button,
- self.privacy_page.block_button, self.privacy_page.unblock_button]
+ self.privacy_page.block_button, self.privacy_page.unblock_button,
+ self.privacy_page.ads_off_button, self.privacy_page.ads_restore_button]
def _set_busy(self, busy):
for b in self._action_buttons():
diff --git a/views/privacy_controller.py b/views/privacy_controller.py
index 8ad4914..65dac48 100644
--- a/views/privacy_controller.py
+++ b/views/privacy_controller.py
@@ -1,16 +1,24 @@
-"""Privacy tab controller: owns the handler logic for blocking/unblocking
-ad and telemetry domains in an instance's guest hosts file.
+"""Privacy tab controller: BlueStacks' own ad/telemetry switches (global) and
+the in-guest tracker block (per instance).
Extraction of responsibility out of ``MainWindow``, same pattern as
``MagiskController`` -- constructed with the owning ``MainWindow`` and reaches
back into it for the confirm dialog, the async job runner, and the Privacy
page widget.
+
+The two controls are deliberately separate. The ad switches are what actually
+stop BlueStacks' advertising (it is served by the Windows player, so no guest
+edit can reach it) and they live in the one global config. The hosts block only
+reaches apps running inside the emulator, and because it modifies the guest
+system image it needs the engine patch -- without it BlueStacks detects the
+tampering and shuts the instance down mid-session.
"""
from __future__ import annotations
from PyQt5.QtCore import QThread
from PyQt5.QtWidgets import QMessageBox
+import ad_settings
import constants
import instance_handler
import telemetry_block
@@ -20,52 +28,164 @@ class PrivacyController:
def __init__(self, window):
self._window = window
+ # --- shared -------------------------------------------------------------
+
+ def _config_path(self):
+ """BlueStacks' single global config. Any instance points at the same one."""
+ for data in self._window.instance_data.values():
+ path = data.get("config_path")
+ if path:
+ return path
+ return None
+
def refresh_statuses(self) -> None:
- """Fill the Privacy tab with each instance's current telemetry-block state."""
+ """Fill the Privacy tab: global ad-switch state + per-instance blocks."""
w = self._window
statuses = {uid: telemetry_block.status(data["data_path"])
for uid, data in w.instance_data.items()}
w.privacy_page.set_instances(statuses)
- def handle_block(self) -> None:
+ config_path = self._config_path()
+ if not config_path:
+ w.privacy_page.set_ad_status(None, 0)
+ return
+ try:
+ total = len(ad_settings.discover(config_path))
+ w.privacy_page.set_ad_status(ad_settings.status(config_path), total)
+ except OSError:
+ w.privacy_page.set_ad_status(None, 0)
+
+ # --- global: BlueStacks' own ad/telemetry switches -----------------------
+
+ def handle_ads_off(self) -> None:
+ w = self._window
+ config_path = self._config_path()
+ if not config_path:
+ QMessageBox.information(w, "No BlueStacks config found",
+ "BlueStacks and its instances need to be "
+ "detected first.")
+ return
+ if not w._confirm(
+ "Turn off ads & telemetry",
+ "Turn off BlueStacks' own ad and telemetry switches?",
+ "Turns off every advertising, promo and stats-upload switch "
+ "found in bluestacks.conf. All BlueStacks processes "
+ "close first, because BlueStacks rewrites that file on exit.
"
+ "This is BlueStacks' one shared config, so it applies to "
+ "every instance, not just one.
"
+ "Fully reversible: each switch's original value is recorded, "
+ "and Restore BlueStacks defaults puts them all back.
"):
+ return
+
+ def job(progress):
+ progress("Closing BlueStacks...", 0)
+ instance_handler.terminate_bluestacks()
+ QThread.msleep(constants.PROCESS_TERMINATION_WAIT_MS)
+ results = ad_settings.apply(config_path, progress=lambda m: progress(m, -1))
+ return results[-1] if results else "Ads and telemetry turned off."
+
+ w._run_async(job, "Turning off BlueStacks ads & telemetry...")
+
+ def handle_ads_restore(self) -> None:
+ w = self._window
+ config_path = self._config_path()
+ if not config_path:
+ return
+ if not w._confirm(
+ "Restore BlueStacks defaults",
+ "Put BlueStacks' ad and telemetry switches back?",
+ "Restores every switch to the value it had before this tool "
+ "changed it. All BlueStacks processes close first.
"):
+ return
+
+ def job(progress):
+ progress("Closing BlueStacks...", 0)
+ instance_handler.terminate_bluestacks()
+ QThread.msleep(constants.PROCESS_TERMINATION_WAIT_MS)
+ results = ad_settings.remove(config_path, progress=lambda m: progress(m, -1))
+ return results[-1] if results else "BlueStacks ad settings restored."
+
+ w._run_async(job, "Restoring BlueStacks ad settings...")
+
+ def handle_ads_lock(self, checked: bool) -> None:
+ """Pin/unpin bluestacks.conf read-only so the switches can't be reverted."""
+ w = self._window
+ config_path = self._config_path()
+ if not config_path:
+ return
+ try:
+ if checked:
+ ad_settings.lock(config_path)
+ else:
+ ad_settings.unlock(config_path)
+ except OSError as exc:
+ QMessageBox.warning(w, "Could not change the config lock", str(exc))
+ finally:
+ self.refresh_statuses()
+
+ # --- per instance: guest hosts block -------------------------------------
+
+ def _selected_instance(self):
w = self._window
uid = w.privacy_page.selected_instance_id()
if not uid or uid not in w.instance_data:
QMessageBox.information(w, "No instance selected",
"Select an instance on the Privacy tab first.")
+ return None, None
+ return uid, w.instance_data[uid]
+
+ def handle_block(self) -> None:
+ w = self._window
+ uid, instance = self._selected_instance()
+ if instance is None:
+ return
+ # Editing the guest hosts file modifies the system image. On an unpatched
+ # engine BlueStacks detects that and shuts the instance down mid-session
+ # ("illegally tampered") -- root isn't required to trip it, any change is.
+ if instance.get("patch_mode") and w._engine_state() != "patched":
+ QMessageBox.warning(
+ w, "Patch the engine first",
+ "Blocking trackers edits the guest system image, and BlueStacks "
+ "shuts down an instance whose system image was modified unless "
+ "the engine is patched. Patch it from the Dashboard, then try "
+ "again.\n\nTo stop BlueStacks' own ads you don't need this at "
+ "all. Use \"Turn off ads & telemetry\" above.")
return
if not w._confirm(
- "Block ads & telemetry",
- "Block ad/telemetry domains in %s?" % uid,
+ "Block in-guest trackers",
+ "Block tracker domains inside %s?" % uid,
"Null-routes ad, tracker, and analytics domains in the guest "
"hosts file while the instance is shut down (all BlueStacks "
- "processes close first). Emulator-only, and reversible.
"):
+ "processes close first). Emulator-only, and reversible."
+ "This reaches apps running inside the emulator. It does "
+ "not affect BlueStacks' own ads, which are served by the Windows "
+ "player and never pass through the guest.
"
+ "One master Root.vhd is shared by every instance of this "
+ "Android version, so this applies to all of them.
"):
return
- data_path = w.instance_data[uid]["data_path"]
+ data_path = instance["data_path"]
def job(progress):
progress("Closing BlueStacks...", 0)
instance_handler.terminate_bluestacks()
QThread.msleep(constants.PROCESS_TERMINATION_WAIT_MS)
results = telemetry_block.apply(data_path, progress=lambda m: progress(m, -1))
- return results[-1] if results else "Telemetry blocked."
+ return results[-1] if results else "Trackers blocked."
- w._run_async(job, "Blocking ads/telemetry in %s..." % uid)
+ w._run_async(job, "Blocking trackers in %s..." % uid)
def handle_unblock(self) -> None:
w = self._window
- uid = w.privacy_page.selected_instance_id()
- if not uid or uid not in w.instance_data:
- QMessageBox.information(w, "No instance selected",
- "Select an instance on the Privacy tab first.")
+ uid, instance = self._selected_instance()
+ if instance is None:
return
if not w._confirm(
- "Remove telemetry block",
+ "Remove tracker block",
"Restore the original guest hosts file for %s?" % uid,
- "Removes the ad/telemetry block, while the instance is shut "
- "down (all BlueStacks processes close first).
"):
+ "Removes the in-guest tracker block, while the instance is "
+ "shut down (all BlueStacks processes close first).
"):
return
- data_path = w.instance_data[uid]["data_path"]
+ data_path = instance["data_path"]
def job(progress):
progress("Closing BlueStacks...", 0)
diff --git a/views/privacy_page.py b/views/privacy_page.py
index 86e0203..24354dc 100644
--- a/views/privacy_page.py
+++ b/views/privacy_page.py
@@ -1,73 +1,180 @@
-"""Privacy page: block ad/telemetry domains in an instance's guest hosts file.
-
-Offline + reversible, per Android version (Root.vhd is shared across instances
-of a version). Emulator-only -- never touches the user's Windows hosts.
+"""Privacy page: two independent controls, deliberately kept apart because they
+have very different reach.
+
+**BlueStacks ads & telemetry** (top, global) flips BlueStacks' own switches in
+``bluestacks.conf``. This is the one that actually stops the ads: they are
+served by ``HD-Player.exe`` on Windows, and a live capture measured the player's
+ad/tracker endpoints going 40 -> 0 with these switches off. It applies to every
+instance, because that config file is global.
+
+**In-guest tracker block** (bottom, per instance) null-routes tracker domains in
+one Android version's guest hosts file. It reaches apps running *inside* the
+emulator -- it cannot touch BlueStacks' own ads, which never go through the
+guest at all. It also modifies the system image, so it needs the engine patch.
"""
from __future__ import annotations
from PyQt5.QtCore import pyqtSignal
from PyQt5.QtWidgets import (
QWidget, QVBoxLayout, QHBoxLayout, QLabel, QRadioButton, QButtonGroup,
- QPushButton,
+ QPushButton, QGroupBox, QCheckBox,
)
class PrivacyPage(QWidget):
+ # global BlueStacks ad/telemetry switches
+ ads_off_requested = pyqtSignal()
+ ads_restore_requested = pyqtSignal()
+ ads_lock_toggled = pyqtSignal(bool)
+ # per-instance guest hosts block
block_requested = pyqtSignal()
unblock_requested = pyqtSignal()
_EMPTY_TEXT = ("No instances detected yet. They appear here once BlueStacks "
"and its instances are found.")
- _PROMPT_TEXT = "Select an instance to see its telemetry-block status."
+ _PROMPT_TEXT = "Select an instance to see its tracker-block status."
+ _ADS_NOTE = (
+ "Turns off BlueStacks' own advertising and stats-upload switches in its "
+ "config. This is what actually stops the ads, and it applies to every "
+ "instance. Close BlueStacks first, since it rewrites the file on exit."
+ )
_NOTE = (
- "Null-routes ad, tracker, and analytics domains in the guest hosts file, "
- "offline. Emulator only (never your Windows machine), reversible, and it "
- "never touches Google Play, GMS, or an app's own servers."
+ "Null-routes tracker domains in the guest hosts file, offline, for apps "
+ "running inside the emulator. Emulator only (never your Windows machine) "
+ "and reversible. It does not affect BlueStacks' own ads, which are served "
+ "by the Windows player: use the control above for those."
)
def __init__(self, parent=None):
super().__init__(parent)
layout = QVBoxLayout(self)
- layout.addWidget(QLabel("1. Choose an instance"))
+ # --- global: BlueStacks' own ad/telemetry switches -------------------
+ ads_box = QGroupBox("BlueStacks ads && telemetry (all instances)")
+ ads_layout = QVBoxLayout(ads_box)
+
+ self.ads_status_label = QLabel("Checking BlueStacks ad settings...")
+ self.ads_status_label.setWordWrap(True)
+ self.ads_status_label.setObjectName("PrivacyAdsStatus")
+ ads_layout.addWidget(self.ads_status_label)
+
+ ads_row = QHBoxLayout()
+ self.ads_off_button = QPushButton("Turn off ads && telemetry")
+ self.ads_off_button.setToolTip(
+ "Turns off every ad, promo and stats-upload switch found in "
+ "bluestacks.conf. Closes BlueStacks first; fully reversible.")
+ self.ads_off_button.clicked.connect(self.ads_off_requested.emit)
+ self.ads_restore_button = QPushButton("Restore BlueStacks defaults")
+ self.ads_restore_button.setToolTip(
+ "Puts every switch back to the value it had before this tool "
+ "changed it.")
+ self.ads_restore_button.clicked.connect(self.ads_restore_requested.emit)
+ ads_row.addWidget(self.ads_off_button)
+ ads_row.addWidget(self.ads_restore_button)
+ ads_layout.addLayout(ads_row)
+
+ self.ads_lock_check = QCheckBox(
+ "Pin the config so BlueStacks cannot turn them back on")
+ self.ads_lock_check.setToolTip(
+ "Marks bluestacks.conf read-only. BlueStacks puts some switches back "
+ "on every start, mostly the stats beacons. Pinning holds them, but "
+ "it also stops BlueStacks saving its own settings changes.")
+ self.ads_lock_check.toggled.connect(self._on_lock_toggled)
+ ads_layout.addWidget(self.ads_lock_check)
+
+ ads_note = QLabel(self._ADS_NOTE)
+ ads_note.setWordWrap(True)
+ ads_note.setObjectName("PrivacyNote")
+ ads_layout.addWidget(ads_note)
+ layout.addWidget(ads_box)
+
+ # --- per instance: guest hosts block ---------------------------------
+ guest_box = QGroupBox("In-guest tracker block (one Android version)")
+ guest_layout = QVBoxLayout(guest_box)
+
+ guest_layout.addWidget(QLabel("1. Choose an instance"))
self.instance_group = QButtonGroup(self)
self.instance_group.setExclusive(True)
self._instance_layout = QVBoxLayout()
- layout.addLayout(self._instance_layout)
+ guest_layout.addLayout(self._instance_layout)
self.no_instances_label = QLabel(self._EMPTY_TEXT)
self.no_instances_label.setWordWrap(True)
self.no_instances_label.hide()
- layout.addWidget(self.no_instances_label)
+ guest_layout.addWidget(self.no_instances_label)
self.status_label = QLabel(self._PROMPT_TEXT)
self.status_label.setWordWrap(True)
self.status_label.setObjectName("PrivacyStatus")
- layout.addWidget(self.status_label)
+ guest_layout.addWidget(self.status_label)
button_row = QHBoxLayout()
- self.block_button = QPushButton("Block ads & telemetry")
+ self.block_button = QPushButton("Block in-guest trackers")
self.block_button.setToolTip(
- "Writes the block into the guest hosts file offline. Closes BlueStacks "
- "first; reversible.")
+ "Writes the block into the guest hosts file offline. Closes "
+ "BlueStacks first; reversible. Needs the engine patch.")
self.block_button.clicked.connect(self.block_requested.emit)
self.unblock_button = QPushButton("Remove block")
self.unblock_button.setToolTip("Restores the guest hosts file offline.")
self.unblock_button.clicked.connect(self.unblock_requested.emit)
button_row.addWidget(self.block_button)
button_row.addWidget(self.unblock_button)
- layout.addLayout(button_row)
+ guest_layout.addLayout(button_row)
note = QLabel(self._NOTE)
note.setWordWrap(True)
note.setObjectName("PrivacyNote")
- layout.addWidget(note)
+ guest_layout.addWidget(note)
+ layout.addWidget(guest_box)
layout.addStretch(1)
self._radios: dict[str, QRadioButton] = {}
self._statuses: dict[str, dict | None] = {}
+ self._ads_status: dict | None = None
+ self._ads_total = 0
self._busy = False
+ self._emit_lock = True
self._update()
+ # --- global ad settings --------------------------------------------------
+
+ def _on_lock_toggled(self, checked: bool) -> None:
+ # set_ad_status() drives the checkbox to match reality; only a real user
+ # click should reach the controller.
+ if self._emit_lock:
+ self.ads_lock_toggled.emit(checked)
+
+ def set_ad_status(self, status: dict | None, total_switches: int = 0) -> None:
+ """``status`` is ad_settings.status() (None when not applied);
+ ``total_switches`` is how many switches the current config exposes."""
+ self._ads_status = status
+ self._ads_total = total_switches
+ self._emit_lock = False
+ self.ads_lock_check.setChecked(bool(status and status.get("locked")))
+ self._emit_lock = True
+ self._update()
+
+ def _ads_status_text(self) -> str:
+ st = self._ads_status
+ if not st:
+ if not self._ads_total:
+ return ("BlueStacks ad settings: no switches found in this build. "
+ "Nothing to turn off here.")
+ return ("BlueStacks ads and telemetry are ON (%d switches available)."
+ % self._ads_total)
+ reverted = st.get("reverted") or []
+ text = "BlueStacks ads and telemetry are OFF (%d switches)." % st.get("keys", 0)
+ if reverted:
+ text += (" BlueStacks has turned %d back on since, mostly stats "
+ "beacons. Turn them off again, or pin the config to hold them."
+ % len(reverted))
+ unmanaged = st.get("unmanaged") or []
+ if unmanaged:
+ text += (" This BlueStacks build added %d new switch(es); turning off "
+ "again will cover them." % len(unmanaged))
+ return text
+
+ # --- per-instance guest block -------------------------------------------
+
def set_busy(self, busy: bool) -> None:
self._busy = busy
self._update()
@@ -111,16 +218,30 @@ def _status_text(self, uid) -> str:
st = self._statuses.get(uid)
if not st:
return "%s: no telemetry block applied." % uid
- return "%s: blocking %s ad/telemetry domains." % (uid, st.get("domains", "?"))
+ return "%s: blocking %s tracker domains in-guest." % (uid, st.get("domains", "?"))
def _update(self, *_args) -> None:
+ busy = self._busy
+
+ applied = bool(self._ads_status)
+ has_switches = bool(self._ads_total)
+ # Offer "turn off" whenever anything is still on (including after
+ # BlueStacks reverts a key), and "restore" once we've recorded originals.
+ reverted = bool(applied and self._ads_status.get("reverted"))
+ unmanaged = bool(applied and self._ads_status.get("unmanaged"))
+ show_off = has_switches and (not applied or reverted or unmanaged)
+ self.ads_status_label.setText(self._ads_status_text())
+ self.ads_off_button.setVisible(show_off)
+ self.ads_off_button.setEnabled(show_off and not busy)
+ self.ads_restore_button.setVisible(applied)
+ self.ads_restore_button.setEnabled(applied and not busy)
+ self.ads_lock_check.setEnabled(has_switches and not busy)
+
uid = self.selected_instance_id()
blocked = bool(uid and self._statuses.get(uid))
self.status_label.setText(self._status_text(uid))
- # Block when an instance is chosen and it's not blocked; Remove once it is.
show_block = bool(uid) and not blocked
self.block_button.setVisible(show_block)
self.unblock_button.setVisible(blocked)
- busy = self._busy
self.block_button.setEnabled(show_block and not busy)
self.unblock_button.setEnabled(blocked and not busy)