1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// API invoked by the browser MediaRouterWebUIMessageHandler to communicate
// with this UI.
cr.define('media_router.ui', function() {
'use strict';
// The media-router-container element.
var container = null;
// The media-router-header element.
var header = null;
// The route-controls element. Is null if the route details view isn't open.
var routeControls = null;
// The initial height for |container|.
var initialMaxHeight = 0;
/**
* Handles response of previous create route attempt.
*
* @param {string} sinkId The ID of the sink to which the Media Route was
* creating a route.
* @param {?media_router.Route} route The newly created route that
* corresponds to the sink if route creation succeeded; null otherwise.
* @param {boolean} isForDisplay Whether or not |route| is for display.
*/
function onCreateRouteResponseReceived(sinkId, route, isForDisplay) {
container.onCreateRouteResponseReceived(sinkId, route, isForDisplay);
}
/**
* Called when the route controller for the route that is currently selected
* is invalidated.
*/
function onRouteControllerInvalidated() {
container.onRouteControllerInvalidated();
}
/**
* Handles the search response by forwarding |sinkId| to the container.
*
* @param {string} sinkId The ID of the sink found by search.
*/
function receiveSearchResult(sinkId) {
container.onReceiveSearchResult(sinkId);
}
/**
* Sets the cast mode list.
*
* @param {!Array<!media_router.CastMode>} castModeList
*/
function setCastModeList(castModeList) {
container.castModeList = castModeList;
}
/**
* Sets |container| and |header|.
*
* @param {!MediaRouterContainerInterface} mediaRouterContainer
* @param {!MediaRouterHeaderElement} mediaRouterHeader
*/
function setElements(mediaRouterContainer, mediaRouterHeader) {
container = mediaRouterContainer;
header = mediaRouterHeader;
if (initialMaxHeight) {
container.updateMaxDialogHeight(initialMaxHeight);
initialMaxHeight = 0;
}
}
/**
* Populates the WebUI with data obtained about the first run flow.
*
* @param {{firstRunFlowCloudPrefLearnMoreUrl: string,
* firstRunFlowLearnMoreUrl: string,
* wasFirstRunFlowAcknowledged: boolean,
* showFirstRunFlowCloudPref: boolean}} data
* Parameters in data:
* firstRunFlowCloudPrefLearnMoreUrl - url to open when the cloud services
* pref learn more link is clicked.
* firstRunFlowLearnMoreUrl - url to open when the first run flow learn
* more link is clicked.
* wasFirstRunFlowAcknowledged - true if first run flow was previously
* acknowledged by user.
* showFirstRunFlowCloudPref - true if the cloud pref option should be
* shown.
*/
function setFirstRunFlowData(data) {
container.firstRunFlowCloudPrefLearnMoreUrl =
data['firstRunFlowCloudPrefLearnMoreUrl'];
container.firstRunFlowLearnMoreUrl = data['firstRunFlowLearnMoreUrl'];
container.showFirstRunFlowCloudPref = data['showFirstRunFlowCloudPref'];
// Some users acknowledged the first run flow before the cloud prefs
// setting was implemented. These users will see the first run flow
// again.
container.showFirstRunFlow = !data['wasFirstRunFlowAcknowledged'] ||
container.showFirstRunFlowCloudPref;
}
/**
* Populates the WebUI with data obtained from Media Router.
*
* @param {{deviceMissingUrl: string,
* sinksAndIdentity: {
* sinks: !Array<!media_router.Sink>,
* showEmail: boolean,
* userEmail: string,
* showDomain: boolean
* },
* routes: !Array<!media_router.Route>,
* castModes: !Array<!media_router.CastMode>,
* useTabMirroring: boolean}} data
* Parameters in data:
* deviceMissingUrl - url to be opened on "Device missing?" clicked.
* sinksAndIdentity - list of sinks to be displayed and user identity.
* useWebUiRouteControls - whether new WebUI route controls should be used.
* routes - list of routes that are associated with the sinks.
* castModes - list of available cast modes.
* useTabMirroring - whether the cast mode should be set to TAB_MIRROR.
*/
function setInitialData(data) {
container.deviceMissingUrl = data['deviceMissingUrl'];
container.castModeList = data['castModes'];
this.setSinkListAndIdentity(data['sinksAndIdentity']);
container.routeList = data['routes'];
container.maybeShowRouteDetailsOnOpen();
if (data['useTabMirroring'])
container.selectCastMode(media_router.CastModeType.TAB_MIRROR);
media_router.browserApi.onInitialDataReceived();
}
/**
* Sets current issue to |issue|, or clears the current issue if |issue| is
* null.
*
* @param {?media_router.Issue} issue
*/
function setIssue(issue) {
container.issue = issue;
}
/**
* Sets |routeControls|. The argument may be null if the route details view is
* getting closed.
*
* @param {?RouteControlsInterface} mediaRouterRouteControls
*/
function setRouteControls(mediaRouterRouteControls) {
routeControls = mediaRouterRouteControls;
}
/**
* Sets the list of currently active routes.
*
* @param {!Array<!media_router.Route>} routeList
*/
function setRouteList(routeList) {
container.routeList = routeList;
}
/**
* Sets the list of discovered sinks along with properties of whether to hide
* identity of the user email and domain.
*
* @param {{sinks: !Array<!media_router.Sink>,
* showEmail: boolean,
* userEmail: string,
* showDomain: boolean}} data
* Parameters in data:
* sinks - list of sinks to be displayed.
* showEmail - true if the user email should be shown.
* userEmail - email of the user if the user is signed in.
* showDomain - true if the user domain should be shown.
*/
function setSinkListAndIdentity(data) {
container.showDomain = data['showDomain'];
container.allSinks = data['sinks'];
header.userEmail = data['userEmail'];
header.showEmail = data['showEmail'];
}
/**
* Updates the max height of the dialog
*
* @param {number} height
*/
function updateMaxHeight(height) {
if (container) {
container.updateMaxDialogHeight(height);
} else {
// Update the max height once |container| gets set.
initialMaxHeight = height;
}
}
/**
* Updates the route status shown in the route controls.
*
* @param {!media_router.RouteStatus} status
*/
function updateRouteStatus(status) {
if (routeControls) {
routeControls.routeStatus = status;
}
}
function userSelectedLocalMediaFile(fileName) {
container.onFileDialogSuccess(fileName);
}
return {
onCreateRouteResponseReceived: onCreateRouteResponseReceived,
onRouteControllerInvalidated: onRouteControllerInvalidated,
receiveSearchResult: receiveSearchResult,
setCastModeList: setCastModeList,
setElements: setElements,
setFirstRunFlowData: setFirstRunFlowData,
setInitialData: setInitialData,
setIssue: setIssue,
setRouteControls: setRouteControls,
setRouteList: setRouteList,
setSinkListAndIdentity: setSinkListAndIdentity,
updateMaxHeight: updateMaxHeight,
updateRouteStatus: updateRouteStatus,
userSelectedLocalMediaFile: userSelectedLocalMediaFile,
};
});
|
