bauiv1lib.gather.privatetab

   1# Released under the MIT License. See LICENSE for details.
   2#
   3# pylint: disable=too-many-lines
   4"""Defines the Private tab in the gather UI."""
   5
   6from __future__ import annotations
   7
   8import os
   9import copy
  10import time
  11import logging
  12from enum import Enum
  13from dataclasses import dataclass
  14from typing import TYPE_CHECKING, cast
  15
  16from efro.dataclassio import dataclass_from_dict, dataclass_to_dict
  17from bacommon.net import (
  18    PrivateHostingState,
  19    PrivateHostingConfig,
  20    PrivatePartyConnectResult,
  21)
  22from bauiv1lib.gather import GatherTab
  23from bauiv1lib.getcurrency import GetCurrencyWindow, show_get_tickets_prompt
  24import bascenev1 as bs
  25import bauiv1 as bui
  26
  27if TYPE_CHECKING:
  28    from typing import Any
  29
  30    from bauiv1lib.gather import GatherWindow
  31
  32
  33# Print a bit of info about queries, etc.
  34DEBUG_SERVER_COMMUNICATION = os.environ.get('BA_DEBUG_PPTABCOM') == '1'
  35
  36
  37class SubTabType(Enum):
  38    """Available sub-tabs."""
  39
  40    JOIN = 'join'
  41    HOST = 'host'
  42
  43
  44@dataclass
  45class State:
  46    """Our core state that persists while the app is running."""
  47
  48    sub_tab: SubTabType = SubTabType.JOIN
  49
  50
  51class PrivateGatherTab(GatherTab):
  52    """The private tab in the gather UI"""
  53
  54    def __init__(self, window: GatherWindow) -> None:
  55        super().__init__(window)
  56        self._container: bui.Widget | None = None
  57        self._state: State = State()
  58        self._hostingstate = PrivateHostingState()
  59        self._join_sub_tab_text: bui.Widget | None = None
  60        self._host_sub_tab_text: bui.Widget | None = None
  61        self._update_timer: bui.AppTimer | None = None
  62        self._join_party_code_text: bui.Widget | None = None
  63        self._c_width: float = 0.0
  64        self._c_height: float = 0.0
  65        self._last_hosting_state_query_time: float | None = None
  66        self._waiting_for_initial_state = True
  67        self._waiting_for_start_stop_response = True
  68        self._host_playlist_button: bui.Widget | None = None
  69        self._host_copy_button: bui.Widget | None = None
  70        self._host_connect_button: bui.Widget | None = None
  71        self._host_start_stop_button: bui.Widget | None = None
  72        self._get_tickets_button: bui.Widget | None = None
  73        self._ticket_count_text: bui.Widget | None = None
  74        self._showing_not_signed_in_screen = False
  75        self._create_time = time.time()
  76        self._last_action_send_time: float | None = None
  77        self._connect_press_time: float | None = None
  78        try:
  79            self._hostingconfig = self._build_hosting_config()
  80        except Exception:
  81            logging.exception('Error building hosting config.')
  82            self._hostingconfig = PrivateHostingConfig()
  83
  84    def on_activate(
  85        self,
  86        parent_widget: bui.Widget,
  87        tab_button: bui.Widget,
  88        region_width: float,
  89        region_height: float,
  90        region_left: float,
  91        region_bottom: float,
  92    ) -> bui.Widget:
  93        self._c_width = region_width
  94        self._c_height = region_height - 20
  95        self._container = bui.containerwidget(
  96            parent=parent_widget,
  97            position=(
  98                region_left,
  99                region_bottom + (region_height - self._c_height) * 0.5,
 100            ),
 101            size=(self._c_width, self._c_height),
 102            background=False,
 103            selection_loops_to_parent=True,
 104        )
 105        v = self._c_height - 30.0
 106        self._join_sub_tab_text = bui.textwidget(
 107            parent=self._container,
 108            position=(self._c_width * 0.5 - 245, v - 13),
 109            color=(0.6, 1.0, 0.6),
 110            scale=1.3,
 111            size=(200, 30),
 112            maxwidth=250,
 113            h_align='left',
 114            v_align='center',
 115            click_activate=True,
 116            selectable=True,
 117            autoselect=True,
 118            on_activate_call=lambda: self._set_sub_tab(
 119                SubTabType.JOIN,
 120                playsound=True,
 121            ),
 122            text=bui.Lstr(resource='gatherWindow.privatePartyJoinText'),
 123        )
 124        self._host_sub_tab_text = bui.textwidget(
 125            parent=self._container,
 126            position=(self._c_width * 0.5 + 45, v - 13),
 127            color=(0.6, 1.0, 0.6),
 128            scale=1.3,
 129            size=(200, 30),
 130            maxwidth=250,
 131            h_align='left',
 132            v_align='center',
 133            click_activate=True,
 134            selectable=True,
 135            autoselect=True,
 136            on_activate_call=lambda: self._set_sub_tab(
 137                SubTabType.HOST,
 138                playsound=True,
 139            ),
 140            text=bui.Lstr(resource='gatherWindow.privatePartyHostText'),
 141        )
 142        bui.widget(edit=self._join_sub_tab_text, up_widget=tab_button)
 143        bui.widget(
 144            edit=self._host_sub_tab_text,
 145            left_widget=self._join_sub_tab_text,
 146            up_widget=tab_button,
 147        )
 148        bui.widget(
 149            edit=self._join_sub_tab_text, right_widget=self._host_sub_tab_text
 150        )
 151
 152        self._update_timer = bui.AppTimer(
 153            1.0, bui.WeakCall(self._update), repeat=True
 154        )
 155
 156        # Prevent taking any action until we've updated our state.
 157        self._waiting_for_initial_state = True
 158
 159        # This will get a state query sent out immediately.
 160        self._last_action_send_time = None  # Ensure we don't ignore response.
 161        self._last_hosting_state_query_time = None
 162        self._update()
 163
 164        self._set_sub_tab(self._state.sub_tab)
 165
 166        return self._container
 167
 168    def _build_hosting_config(self) -> PrivateHostingConfig:
 169        # pylint: disable=too-many-branches
 170        # pylint: disable=too-many-locals
 171        from bauiv1lib.playlist import PlaylistTypeVars
 172        from bascenev1 import filter_playlist
 173
 174        hcfg = PrivateHostingConfig()
 175        cfg = bui.app.config
 176        sessiontypestr = cfg.get('Private Party Host Session Type', 'ffa')
 177        if not isinstance(sessiontypestr, str):
 178            raise RuntimeError(f'Invalid sessiontype {sessiontypestr}')
 179        hcfg.session_type = sessiontypestr
 180
 181        sessiontype: type[bs.Session]
 182        if hcfg.session_type == 'ffa':
 183            sessiontype = bs.FreeForAllSession
 184        elif hcfg.session_type == 'teams':
 185            sessiontype = bs.DualTeamSession
 186        else:
 187            raise RuntimeError(f'Invalid sessiontype: {hcfg.session_type}')
 188        pvars = PlaylistTypeVars(sessiontype)
 189
 190        playlist_name = bui.app.config.get(
 191            f'{pvars.config_name} Playlist Selection'
 192        )
 193        if not isinstance(playlist_name, str):
 194            playlist_name = '__default__'
 195        hcfg.playlist_name = (
 196            pvars.default_list_name.evaluate()
 197            if playlist_name == '__default__'
 198            else playlist_name
 199        )
 200
 201        playlist: list[dict[str, Any]] | None = None
 202        if playlist_name != '__default__':
 203            playlist = cfg.get(f'{pvars.config_name} Playlists', {}).get(
 204                playlist_name
 205            )
 206        if playlist is None:
 207            playlist = pvars.get_default_list_call()
 208
 209        hcfg.playlist = filter_playlist(
 210            playlist, sessiontype, name=playlist_name
 211        )
 212
 213        randomize = cfg.get(f'{pvars.config_name} Playlist Randomize')
 214        if not isinstance(randomize, bool):
 215            randomize = False
 216        hcfg.randomize = randomize
 217
 218        tutorial = cfg.get('Show Tutorial')
 219        if not isinstance(tutorial, bool):
 220            tutorial = True
 221        hcfg.tutorial = tutorial
 222
 223        if hcfg.session_type == 'teams':
 224            ctn: list[str] | None = cfg.get('Custom Team Names')
 225            if ctn is not None:
 226                ctn_any: Any = ctn  # Actual value may not match type checker.
 227                if (
 228                    isinstance(ctn_any, (list, tuple))
 229                    and len(ctn) == 2
 230                    and all(isinstance(x, str) for x in ctn)
 231                ):
 232                    hcfg.custom_team_names = (ctn[0], ctn[1])
 233                else:
 234                    print(f'Found invalid custom-team-names data: {ctn}')
 235
 236            ctc: list[list[float]] | None = cfg.get('Custom Team Colors')
 237            if ctc is not None:
 238                ctc_any: Any = ctc  # Actual value may not match type checker.
 239                if (
 240                    isinstance(ctc_any, (list, tuple))
 241                    and len(ctc) == 2
 242                    and all(isinstance(x, (list, tuple)) for x in ctc)
 243                    and all(len(x) == 3 for x in ctc)
 244                ):
 245                    hcfg.custom_team_colors = (
 246                        (ctc[0][0], ctc[0][1], ctc[0][2]),
 247                        (ctc[1][0], ctc[1][1], ctc[1][2]),
 248                    )
 249                else:
 250                    print(f'Found invalid custom-team-colors data: {ctc}')
 251
 252        return hcfg
 253
 254    def on_deactivate(self) -> None:
 255        self._update_timer = None
 256
 257    def _update_currency_ui(self) -> None:
 258        # Keep currency count up to date if applicable.
 259        plus = bui.app.plus
 260        assert plus is not None
 261
 262        try:
 263            t_str = str(plus.get_v1_account_ticket_count())
 264        except Exception:
 265            t_str = '?'
 266        if self._get_tickets_button:
 267            bui.buttonwidget(
 268                edit=self._get_tickets_button,
 269                label=bui.charstr(bui.SpecialChar.TICKET) + t_str,
 270            )
 271        if self._ticket_count_text:
 272            bui.textwidget(
 273                edit=self._ticket_count_text,
 274                text=bui.charstr(bui.SpecialChar.TICKET) + t_str,
 275            )
 276
 277    def _update(self) -> None:
 278        """Periodic updating."""
 279
 280        plus = bui.app.plus
 281        assert plus is not None
 282
 283        now = bui.apptime()
 284
 285        self._update_currency_ui()
 286
 287        if self._state.sub_tab is SubTabType.HOST:
 288            # If we're not signed in, just refresh to show that.
 289            if (
 290                plus.get_v1_account_state() != 'signed_in'
 291                and self._showing_not_signed_in_screen
 292            ):
 293                self._refresh_sub_tab()
 294            else:
 295                # Query an updated state periodically.
 296                if (
 297                    self._last_hosting_state_query_time is None
 298                    or now - self._last_hosting_state_query_time > 15.0
 299                ):
 300                    self._debug_server_comm('querying private party state')
 301                    if plus.get_v1_account_state() == 'signed_in':
 302                        plus.add_v1_account_transaction(
 303                            {
 304                                'type': 'PRIVATE_PARTY_QUERY',
 305                                'expire_time': time.time() + 20,
 306                            },
 307                            callback=bui.WeakCall(
 308                                self._hosting_state_idle_response
 309                            ),
 310                        )
 311                        plus.run_v1_account_transactions()
 312                    else:
 313                        self._hosting_state_idle_response(None)
 314                    self._last_hosting_state_query_time = now
 315
 316    def _hosting_state_idle_response(
 317        self, result: dict[str, Any] | None
 318    ) -> None:
 319        # This simply passes through to our standard response handler.
 320        # The one exception is if we've recently sent an action to the
 321        # server (start/stop hosting/etc.) In that case we want to ignore
 322        # idle background updates and wait for the response to our action.
 323        # (this keeps the button showing 'one moment...' until the change
 324        # takes effect, etc.)
 325        if (
 326            self._last_action_send_time is not None
 327            and time.time() - self._last_action_send_time < 5.0
 328        ):
 329            self._debug_server_comm(
 330                'ignoring private party state response due to recent action'
 331            )
 332            return
 333        self._hosting_state_response(result)
 334
 335    def _hosting_state_response(self, result: dict[str, Any] | None) -> None:
 336        # Its possible for this to come back to us after our UI is dead;
 337        # ignore in that case.
 338        if not self._container:
 339            return
 340
 341        state: PrivateHostingState | None = None
 342        if result is not None:
 343            self._debug_server_comm('got private party state response')
 344            try:
 345                state = dataclass_from_dict(
 346                    PrivateHostingState, result, discard_unknown_attrs=True
 347                )
 348            except Exception:
 349                logging.exception('Got invalid PrivateHostingState data')
 350        else:
 351            self._debug_server_comm('private party state response errored')
 352
 353        # Hmm I guess let's just ignore failed responses?...
 354        # Or should we show some sort of error state to the user?...
 355        if result is None or state is None:
 356            return
 357
 358        self._waiting_for_initial_state = False
 359        self._waiting_for_start_stop_response = False
 360        self._hostingstate = state
 361        self._refresh_sub_tab()
 362
 363    def _set_sub_tab(self, value: SubTabType, playsound: bool = False) -> None:
 364        assert self._container
 365        if playsound:
 366            bui.getsound('click01').play()
 367
 368        # If switching from join to host, do a fresh state query.
 369        if self._state.sub_tab is SubTabType.JOIN and value is SubTabType.HOST:
 370            # Prevent taking any action until we've gotten a fresh state.
 371            self._waiting_for_initial_state = True
 372
 373            # This will get a state query sent out immediately.
 374            self._last_hosting_state_query_time = None
 375            self._last_action_send_time = None  # So we don't ignore response.
 376            self._update()
 377
 378        self._state.sub_tab = value
 379        active_color = (0.6, 1.0, 0.6)
 380        inactive_color = (0.5, 0.4, 0.5)
 381        bui.textwidget(
 382            edit=self._join_sub_tab_text,
 383            color=active_color if value is SubTabType.JOIN else inactive_color,
 384        )
 385        bui.textwidget(
 386            edit=self._host_sub_tab_text,
 387            color=active_color if value is SubTabType.HOST else inactive_color,
 388        )
 389
 390        self._refresh_sub_tab()
 391
 392        # Kick off an update to get any needed messages sent/etc.
 393        bui.pushcall(self._update)
 394
 395    def _selwidgets(self) -> list[bui.Widget | None]:
 396        """An indexed list of widgets we can use for saving/restoring sel."""
 397        return [
 398            self._host_playlist_button,
 399            self._host_copy_button,
 400            self._host_connect_button,
 401            self._host_start_stop_button,
 402            self._get_tickets_button,
 403        ]
 404
 405    def _refresh_sub_tab(self) -> None:
 406        assert self._container
 407
 408        # Store an index for our current selection so we can
 409        # reselect the equivalent recreated widget if possible.
 410        selindex: int | None = None
 411        selchild = self._container.get_selected_child()
 412        if selchild is not None:
 413            try:
 414                selindex = self._selwidgets().index(selchild)
 415            except ValueError:
 416                pass
 417
 418        # Clear anything existing in the old sub-tab.
 419        for widget in self._container.get_children():
 420            if widget and widget not in {
 421                self._host_sub_tab_text,
 422                self._join_sub_tab_text,
 423            }:
 424                widget.delete()
 425
 426        if self._state.sub_tab is SubTabType.JOIN:
 427            self._build_join_tab()
 428        elif self._state.sub_tab is SubTabType.HOST:
 429            self._build_host_tab()
 430        else:
 431            raise RuntimeError('Invalid state.')
 432
 433        # Select the new equivalent widget if there is one.
 434        if selindex is not None:
 435            selwidget = self._selwidgets()[selindex]
 436            if selwidget:
 437                bui.containerwidget(
 438                    edit=self._container, selected_child=selwidget
 439                )
 440
 441    def _build_join_tab(self) -> None:
 442        bui.textwidget(
 443            parent=self._container,
 444            position=(self._c_width * 0.5, self._c_height - 140),
 445            color=(0.5, 0.46, 0.5),
 446            scale=1.5,
 447            size=(0, 0),
 448            maxwidth=250,
 449            h_align='center',
 450            v_align='center',
 451            text=bui.Lstr(resource='gatherWindow.partyCodeText'),
 452        )
 453
 454        self._join_party_code_text = bui.textwidget(
 455            parent=self._container,
 456            position=(self._c_width * 0.5 - 150, self._c_height - 250),
 457            flatness=1.0,
 458            scale=1.5,
 459            size=(300, 50),
 460            editable=True,
 461            description=bui.Lstr(resource='gatherWindow.partyCodeText'),
 462            autoselect=True,
 463            maxwidth=250,
 464            h_align='left',
 465            v_align='center',
 466            text='',
 467        )
 468        btn = bui.buttonwidget(
 469            parent=self._container,
 470            size=(300, 70),
 471            label=bui.Lstr(resource='gatherWindow.' 'manualConnectText'),
 472            position=(self._c_width * 0.5 - 150, self._c_height - 350),
 473            on_activate_call=self._join_connect_press,
 474            autoselect=True,
 475        )
 476        bui.textwidget(
 477            edit=self._join_party_code_text, on_return_press_call=btn.activate
 478        )
 479
 480    def _on_get_tickets_press(self) -> None:
 481        if self._waiting_for_start_stop_response:
 482            return
 483
 484        # Bring up get-tickets window and then kill ourself (we're on the
 485        # overlay layer so we'd show up above it).
 486        GetCurrencyWindow(modal=True, origin_widget=self._get_tickets_button)
 487
 488    def _build_host_tab(self) -> None:
 489        # pylint: disable=too-many-branches
 490        # pylint: disable=too-many-statements
 491        assert bui.app.classic is not None
 492
 493        plus = bui.app.plus
 494        assert plus is not None
 495
 496        hostingstate = self._hostingstate
 497        if plus.get_v1_account_state() != 'signed_in':
 498            bui.textwidget(
 499                parent=self._container,
 500                size=(0, 0),
 501                h_align='center',
 502                v_align='center',
 503                maxwidth=200,
 504                scale=0.8,
 505                color=(0.6, 0.56, 0.6),
 506                position=(self._c_width * 0.5, self._c_height * 0.5),
 507                text=bui.Lstr(resource='notSignedInErrorText'),
 508            )
 509            self._showing_not_signed_in_screen = True
 510            return
 511        self._showing_not_signed_in_screen = False
 512
 513        # At first we don't want to show anything until we've gotten a state.
 514        # Update: In this situation we now simply show our existing state
 515        # but give the start/stop button a loading message and disallow its
 516        # use. This keeps things a lot less jumpy looking and allows selecting
 517        # playlists/etc without having to wait for the server each time
 518        # back to the ui.
 519        if self._waiting_for_initial_state and bool(False):
 520            bui.textwidget(
 521                parent=self._container,
 522                size=(0, 0),
 523                h_align='center',
 524                v_align='center',
 525                maxwidth=200,
 526                scale=0.8,
 527                color=(0.6, 0.56, 0.6),
 528                position=(self._c_width * 0.5, self._c_height * 0.5),
 529                text=bui.Lstr(
 530                    value='${A}...',
 531                    subs=[('${A}', bui.Lstr(resource='store.loadingText'))],
 532                ),
 533            )
 534            return
 535
 536        # If we're not currently hosting and hosting requires tickets,
 537        # Show our count (possibly with a link to purchase more).
 538        if (
 539            not self._waiting_for_initial_state
 540            and hostingstate.party_code is None
 541            and hostingstate.tickets_to_host_now != 0
 542        ):
 543            if not bui.app.ui_v1.use_toolbars:
 544                if bui.app.classic.allow_ticket_purchases:
 545                    self._get_tickets_button = bui.buttonwidget(
 546                        parent=self._container,
 547                        position=(
 548                            self._c_width - 210 + 125,
 549                            self._c_height - 44,
 550                        ),
 551                        autoselect=True,
 552                        scale=0.6,
 553                        size=(120, 60),
 554                        textcolor=(0.2, 1, 0.2),
 555                        label=bui.charstr(bui.SpecialChar.TICKET),
 556                        color=(0.65, 0.5, 0.8),
 557                        on_activate_call=self._on_get_tickets_press,
 558                    )
 559                else:
 560                    self._ticket_count_text = bui.textwidget(
 561                        parent=self._container,
 562                        scale=0.6,
 563                        position=(
 564                            self._c_width - 210 + 125,
 565                            self._c_height - 44,
 566                        ),
 567                        color=(0.2, 1, 0.2),
 568                        h_align='center',
 569                        v_align='center',
 570                    )
 571                # Set initial ticket count.
 572                self._update_currency_ui()
 573
 574        v = self._c_height - 90
 575        if hostingstate.party_code is None:
 576            bui.textwidget(
 577                parent=self._container,
 578                size=(0, 0),
 579                h_align='center',
 580                v_align='center',
 581                maxwidth=self._c_width * 0.9,
 582                scale=0.7,
 583                flatness=1.0,
 584                color=(0.5, 0.46, 0.5),
 585                position=(self._c_width * 0.5, v),
 586                text=bui.Lstr(
 587                    resource='gatherWindow.privatePartyCloudDescriptionText'
 588                ),
 589            )
 590
 591        v -= 100
 592        if hostingstate.party_code is None:
 593            # We've got no current party running; show options to set one up.
 594            bui.textwidget(
 595                parent=self._container,
 596                size=(0, 0),
 597                h_align='right',
 598                v_align='center',
 599                maxwidth=200,
 600                scale=0.8,
 601                color=(0.6, 0.56, 0.6),
 602                position=(self._c_width * 0.5 - 210, v),
 603                text=bui.Lstr(resource='playlistText'),
 604            )
 605            self._host_playlist_button = bui.buttonwidget(
 606                parent=self._container,
 607                size=(400, 70),
 608                color=(0.6, 0.5, 0.6),
 609                textcolor=(0.8, 0.75, 0.8),
 610                label=self._hostingconfig.playlist_name,
 611                on_activate_call=self._playlist_press,
 612                position=(self._c_width * 0.5 - 200, v - 35),
 613                up_widget=self._host_sub_tab_text,
 614                autoselect=True,
 615            )
 616
 617            # If it appears we're coming back from playlist selection,
 618            # re-select our playlist button.
 619            if bui.app.ui_v1.selecting_private_party_playlist:
 620                bui.containerwidget(
 621                    edit=self._container,
 622                    selected_child=self._host_playlist_button,
 623                )
 624                bui.app.ui_v1.selecting_private_party_playlist = False
 625        else:
 626            # We've got a current party; show its info.
 627            bui.textwidget(
 628                parent=self._container,
 629                size=(0, 0),
 630                h_align='center',
 631                v_align='center',
 632                maxwidth=600,
 633                scale=0.9,
 634                color=(0.7, 0.64, 0.7),
 635                position=(self._c_width * 0.5, v + 90),
 636                text=bui.Lstr(resource='gatherWindow.partyServerRunningText'),
 637            )
 638            bui.textwidget(
 639                parent=self._container,
 640                size=(0, 0),
 641                h_align='center',
 642                v_align='center',
 643                maxwidth=600,
 644                scale=0.7,
 645                color=(0.7, 0.64, 0.7),
 646                position=(self._c_width * 0.5, v + 50),
 647                text=bui.Lstr(resource='gatherWindow.partyCodeText'),
 648            )
 649            bui.textwidget(
 650                parent=self._container,
 651                size=(0, 0),
 652                h_align='center',
 653                v_align='center',
 654                scale=2.0,
 655                color=(0.0, 1.0, 0.0),
 656                position=(self._c_width * 0.5, v + 10),
 657                text=hostingstate.party_code,
 658            )
 659
 660            # Also action buttons to copy it and connect to it.
 661            if bui.clipboard_is_supported():
 662                cbtnoffs = 10
 663                self._host_copy_button = bui.buttonwidget(
 664                    parent=self._container,
 665                    size=(140, 40),
 666                    color=(0.6, 0.5, 0.6),
 667                    textcolor=(0.8, 0.75, 0.8),
 668                    label=bui.Lstr(resource='gatherWindow.copyCodeText'),
 669                    on_activate_call=self._host_copy_press,
 670                    position=(self._c_width * 0.5 - 150, v - 70),
 671                    autoselect=True,
 672                )
 673            else:
 674                cbtnoffs = -70
 675            self._host_connect_button = bui.buttonwidget(
 676                parent=self._container,
 677                size=(140, 40),
 678                color=(0.6, 0.5, 0.6),
 679                textcolor=(0.8, 0.75, 0.8),
 680                label=bui.Lstr(resource='gatherWindow.manualConnectText'),
 681                on_activate_call=self._host_connect_press,
 682                position=(self._c_width * 0.5 + cbtnoffs, v - 70),
 683                autoselect=True,
 684            )
 685
 686        v -= 120
 687
 688        # Line above the main action button:
 689
 690        # If we don't want to show anything until we get a state:
 691        if self._waiting_for_initial_state:
 692            pass
 693        elif hostingstate.unavailable_error is not None:
 694            # If hosting is unavailable, show the associated reason.
 695            bui.textwidget(
 696                parent=self._container,
 697                size=(0, 0),
 698                h_align='center',
 699                v_align='center',
 700                maxwidth=self._c_width * 0.9,
 701                scale=0.7,
 702                flatness=1.0,
 703                color=(1.0, 0.0, 0.0),
 704                position=(self._c_width * 0.5, v),
 705                text=bui.Lstr(
 706                    translate=(
 707                        'serverResponses',
 708                        hostingstate.unavailable_error,
 709                    )
 710                ),
 711            )
 712        elif hostingstate.free_host_minutes_remaining is not None:
 713            # If we've been pre-approved to start/stop for free, show that.
 714            bui.textwidget(
 715                parent=self._container,
 716                size=(0, 0),
 717                h_align='center',
 718                v_align='center',
 719                maxwidth=self._c_width * 0.9,
 720                scale=0.7,
 721                flatness=1.0,
 722                color=(
 723                    (0.7, 0.64, 0.7)
 724                    if hostingstate.party_code
 725                    else (0.0, 1.0, 0.0)
 726                ),
 727                position=(self._c_width * 0.5, v),
 728                text=bui.Lstr(
 729                    resource='gatherWindow.startStopHostingMinutesText',
 730                    subs=[
 731                        (
 732                            '${MINUTES}',
 733                            f'{hostingstate.free_host_minutes_remaining:.0f}',
 734                        )
 735                    ],
 736                ),
 737            )
 738        else:
 739            # Otherwise tell whether the free cloud server is available
 740            # or will be at some point.
 741            if hostingstate.party_code is None:
 742                if hostingstate.tickets_to_host_now == 0:
 743                    bui.textwidget(
 744                        parent=self._container,
 745                        size=(0, 0),
 746                        h_align='center',
 747                        v_align='center',
 748                        maxwidth=self._c_width * 0.9,
 749                        scale=0.7,
 750                        flatness=1.0,
 751                        color=(0.0, 1.0, 0.0),
 752                        position=(self._c_width * 0.5, v),
 753                        text=bui.Lstr(
 754                            resource=(
 755                                'gatherWindow.freeCloudServerAvailableNowText'
 756                            )
 757                        ),
 758                    )
 759                else:
 760                    if hostingstate.minutes_until_free_host is None:
 761                        bui.textwidget(
 762                            parent=self._container,
 763                            size=(0, 0),
 764                            h_align='center',
 765                            v_align='center',
 766                            maxwidth=self._c_width * 0.9,
 767                            scale=0.7,
 768                            flatness=1.0,
 769                            color=(1.0, 0.6, 0.0),
 770                            position=(self._c_width * 0.5, v),
 771                            text=bui.Lstr(
 772                                resource=(
 773                                    'gatherWindow'
 774                                    '.freeCloudServerNotAvailableText'
 775                                )
 776                            ),
 777                        )
 778                    else:
 779                        availmins = hostingstate.minutes_until_free_host
 780                        bui.textwidget(
 781                            parent=self._container,
 782                            size=(0, 0),
 783                            h_align='center',
 784                            v_align='center',
 785                            maxwidth=self._c_width * 0.9,
 786                            scale=0.7,
 787                            flatness=1.0,
 788                            color=(1.0, 0.6, 0.0),
 789                            position=(self._c_width * 0.5, v),
 790                            text=bui.Lstr(
 791                                resource='gatherWindow.'
 792                                'freeCloudServerAvailableMinutesText',
 793                                subs=[('${MINUTES}', f'{availmins:.0f}')],
 794                            ),
 795                        )
 796
 797        v -= 100
 798
 799        if (
 800            self._waiting_for_start_stop_response
 801            or self._waiting_for_initial_state
 802        ):
 803            btnlabel = bui.Lstr(resource='oneMomentText')
 804        else:
 805            if hostingstate.unavailable_error is not None:
 806                btnlabel = bui.Lstr(
 807                    resource='gatherWindow.hostingUnavailableText'
 808                )
 809            elif hostingstate.party_code is None:
 810                ticon = bui.charstr(bui.SpecialChar.TICKET)
 811                nowtickets = hostingstate.tickets_to_host_now
 812                if nowtickets > 0:
 813                    btnlabel = bui.Lstr(
 814                        resource='gatherWindow.startHostingPaidText',
 815                        subs=[('${COST}', f'{ticon}{nowtickets}')],
 816                    )
 817                else:
 818                    btnlabel = bui.Lstr(
 819                        resource='gatherWindow.startHostingText'
 820                    )
 821            else:
 822                btnlabel = bui.Lstr(resource='gatherWindow.stopHostingText')
 823
 824        disabled = (
 825            hostingstate.unavailable_error is not None
 826            or self._waiting_for_initial_state
 827        )
 828        waiting = self._waiting_for_start_stop_response
 829        self._host_start_stop_button = bui.buttonwidget(
 830            parent=self._container,
 831            size=(400, 80),
 832            color=(
 833                (0.6, 0.6, 0.6)
 834                if disabled
 835                else (0.5, 1.0, 0.5)
 836                if waiting
 837                else None
 838            ),
 839            enable_sound=False,
 840            label=btnlabel,
 841            textcolor=((0.7, 0.7, 0.7) if disabled else None),
 842            position=(self._c_width * 0.5 - 200, v),
 843            on_activate_call=self._start_stop_button_press,
 844            autoselect=True,
 845        )
 846
 847    def _playlist_press(self) -> None:
 848        assert self._host_playlist_button is not None
 849        self.window.playlist_select(origin_widget=self._host_playlist_button)
 850
 851    def _host_copy_press(self) -> None:
 852        assert self._hostingstate.party_code is not None
 853        bui.clipboard_set_text(self._hostingstate.party_code)
 854        bui.screenmessage(bui.Lstr(resource='gatherWindow.copyCodeConfirmText'))
 855
 856    def _host_connect_press(self) -> None:
 857        assert self._hostingstate.party_code is not None
 858        self._connect_to_party_code(self._hostingstate.party_code)
 859
 860    def _debug_server_comm(self, msg: str) -> None:
 861        if DEBUG_SERVER_COMMUNICATION:
 862            print(
 863                f'PPTABCOM: {msg} at time '
 864                f'{time.time()-self._create_time:.2f}'
 865            )
 866
 867    def _connect_to_party_code(self, code: str) -> None:
 868        # Ignore attempted followup sends for a few seconds.
 869        # (this will reset if we get a response)
 870        plus = bui.app.plus
 871        assert plus is not None
 872
 873        now = time.time()
 874        if (
 875            self._connect_press_time is not None
 876            and now - self._connect_press_time < 5.0
 877        ):
 878            self._debug_server_comm(
 879                'not sending private party connect (too soon)'
 880            )
 881            return
 882        self._connect_press_time = now
 883
 884        self._debug_server_comm('sending private party connect')
 885        plus.add_v1_account_transaction(
 886            {
 887                'type': 'PRIVATE_PARTY_CONNECT',
 888                'expire_time': time.time() + 20,
 889                'code': code,
 890            },
 891            callback=bui.WeakCall(self._connect_response),
 892        )
 893        plus.run_v1_account_transactions()
 894
 895    def _start_stop_button_press(self) -> None:
 896        plus = bui.app.plus
 897        assert plus is not None
 898        if (
 899            self._waiting_for_start_stop_response
 900            or self._waiting_for_initial_state
 901        ):
 902            return
 903
 904        if plus.get_v1_account_state() != 'signed_in':
 905            bui.screenmessage(bui.Lstr(resource='notSignedInErrorText'))
 906            bui.getsound('error').play()
 907            self._refresh_sub_tab()
 908            return
 909
 910        if self._hostingstate.unavailable_error is not None:
 911            bui.getsound('error').play()
 912            return
 913
 914        bui.getsound('click01').play()
 915
 916        # If we're not hosting, start.
 917        if self._hostingstate.party_code is None:
 918            # If there's a ticket cost, make sure we have enough tickets.
 919            if self._hostingstate.tickets_to_host_now > 0:
 920                ticket_count: int | None
 921                try:
 922                    ticket_count = plus.get_v1_account_ticket_count()
 923                except Exception:
 924                    # FIXME: should add a bui.NotSignedInError we can use here.
 925                    ticket_count = None
 926                ticket_cost = self._hostingstate.tickets_to_host_now
 927                if ticket_count is not None and ticket_count < ticket_cost:
 928                    show_get_tickets_prompt()
 929                    bui.getsound('error').play()
 930                    return
 931            self._last_action_send_time = time.time()
 932            plus.add_v1_account_transaction(
 933                {
 934                    'type': 'PRIVATE_PARTY_START',
 935                    'config': dataclass_to_dict(self._hostingconfig),
 936                    'region_pings': bui.app.net.zone_pings,
 937                    'expire_time': time.time() + 20,
 938                },
 939                callback=bui.WeakCall(self._hosting_state_response),
 940            )
 941            plus.run_v1_account_transactions()
 942
 943        else:
 944            self._last_action_send_time = time.time()
 945            plus.add_v1_account_transaction(
 946                {
 947                    'type': 'PRIVATE_PARTY_STOP',
 948                    'expire_time': time.time() + 20,
 949                },
 950                callback=bui.WeakCall(self._hosting_state_response),
 951            )
 952            plus.run_v1_account_transactions()
 953        bui.getsound('click01').play()
 954
 955        self._waiting_for_start_stop_response = True
 956        self._refresh_sub_tab()
 957
 958    def _join_connect_press(self) -> None:
 959        # Error immediately if its an empty code.
 960        code: str | None = None
 961        if self._join_party_code_text:
 962            code = cast(str, bui.textwidget(query=self._join_party_code_text))
 963        if not code:
 964            bui.screenmessage(
 965                bui.Lstr(resource='internal.invalidAddressErrorText'),
 966                color=(1, 0, 0),
 967            )
 968            bui.getsound('error').play()
 969            return
 970
 971        self._connect_to_party_code(code)
 972
 973    def _connect_response(self, result: dict[str, Any] | None) -> None:
 974        try:
 975            self._connect_press_time = None
 976            if result is None:
 977                raise RuntimeError()
 978            cresult = dataclass_from_dict(
 979                PrivatePartyConnectResult, result, discard_unknown_attrs=True
 980            )
 981            if cresult.error is not None:
 982                self._debug_server_comm('got error connect response')
 983                bui.screenmessage(
 984                    bui.Lstr(translate=('serverResponses', cresult.error)),
 985                    (1, 0, 0),
 986                )
 987                bui.getsound('error').play()
 988                return
 989            self._debug_server_comm('got valid connect response')
 990            assert cresult.addr is not None and cresult.port is not None
 991            bs.connect_to_party(cresult.addr, port=cresult.port)
 992        except Exception:
 993            self._debug_server_comm('got connect response error')
 994            bui.getsound('error').play()
 995
 996    def save_state(self) -> None:
 997        assert bui.app.classic is not None
 998        bui.app.ui_v1.window_states[type(self)] = copy.deepcopy(self._state)
 999
1000    def restore_state(self) -> None:
1001        assert bui.app.classic is not None
1002        state = bui.app.ui_v1.window_states.get(type(self))
1003        if state is None:
1004            state = State()
1005        assert isinstance(state, State)
1006        self._state = state