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
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.app;
import android.content.Context;
import android.media.MediaRouter;
import android.media.MediaRouter.RouteInfo;
import android.util.Log;
import android.view.ActionProvider;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import java.lang.ref.WeakReference;
/**
* The media route action provider displays a {@link MediaRouteButton media route button}
* in the application's {@link ActionBar} to allow the user to select routes and
* to control the currently selected route.
* <p>
* The application must specify the kinds of routes that the user should be allowed
* to select by specifying the route types with the {@link #setRouteTypes} method.
* </p><p>
* Refer to {@link MediaRouteButton} for a description of the button that will
* appear in the action bar menu. Note that instead of disabling the button
* when no routes are available, the action provider will instead make the
* menu item invisible. In this way, the button will only be visible when it
* is possible for the user to discover and select a matching route.
* </p>
*/
public class MediaRouteActionProvider extends ActionProvider {
private static final String TAG = "MediaRouteActionProvider";
private final Context mContext;
private final MediaRouter mRouter;
private final MediaRouterCallback mCallback;
private int mRouteTypes;
private MediaRouteButton mButton;
private View.OnClickListener mExtendedSettingsListener;
public MediaRouteActionProvider(Context context) {
super(context);
mContext = context;
mRouter = (MediaRouter) context.getSystemService(Context.MEDIA_ROUTER_SERVICE);
mCallback = new MediaRouterCallback(this);
// Start with live audio by default.
// TODO Update this when new route types are added; segment by API level
// when different route types were added.
setRouteTypes(MediaRouter.ROUTE_TYPE_LIVE_AUDIO);
}
/**
* Sets the types of routes that will be shown in the media route chooser dialog
* launched by this button.
*
* @param types The route types to match.
*/
public void setRouteTypes(int types) {
if (mRouteTypes != types) {
// FIXME: We currently have no way of knowing whether the action provider
// is still needed by the UI. Unfortunately this means the action provider
// may leak callbacks until garbage collection occurs. This may result in
// media route providers doing more work than necessary in the short term
// while trying to discover routes that are no longer of interest to the
// application. To solve this problem, the action provider will need some
// indication from the framework that it is being destroyed.
if (mRouteTypes != 0) {
mRouter.removeCallback(mCallback);
}
mRouteTypes = types;
if (types != 0) {
mRouter.addCallback(types, mCallback,
MediaRouter.CALLBACK_FLAG_PASSIVE_DISCOVERY);
}
refreshRoute();
if (mButton != null) {
mButton.setRouteTypes(mRouteTypes);
}
}
}
public void setExtendedSettingsClickListener(View.OnClickListener listener) {
mExtendedSettingsListener = listener;
if (mButton != null) {
mButton.setExtendedSettingsClickListener(listener);
}
}
@Override
@SuppressWarnings("deprecation")
public View onCreateActionView() {
throw new UnsupportedOperationException("Use onCreateActionView(MenuItem) instead.");
}
@Override
public View onCreateActionView(MenuItem item) {
if (mButton != null) {
Log.e(TAG, "onCreateActionView: this ActionProvider is already associated " +
"with a menu item. Don't reuse MediaRouteActionProvider instances! " +
"Abandoning the old one...");
}
mButton = new MediaRouteButton(mContext);
mButton.setCheatSheetEnabled(true);
mButton.setRouteTypes(mRouteTypes);
mButton.setExtendedSettingsClickListener(mExtendedSettingsListener);
mButton.setLayoutParams(new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT,
ViewGroup.LayoutParams.MATCH_PARENT));
return mButton;
}
@Override
public boolean onPerformDefaultAction() {
if (mButton != null) {
return mButton.showDialogInternal();
}
return false;
}
@Override
public boolean overridesItemVisibility() {
return true;
}
@Override
public boolean isVisible() {
return mRouter.isRouteAvailable(mRouteTypes,
MediaRouter.AVAILABILITY_FLAG_IGNORE_DEFAULT_ROUTE);
}
private void refreshRoute() {
refreshVisibility();
}
private static class MediaRouterCallback extends MediaRouter.SimpleCallback {
private final WeakReference<MediaRouteActionProvider> mProviderWeak;
public MediaRouterCallback(MediaRouteActionProvider provider) {
mProviderWeak = new WeakReference<MediaRouteActionProvider>(provider);
}
@Override
public void onRouteAdded(MediaRouter router, RouteInfo info) {
refreshRoute(router);
}
@Override
public void onRouteRemoved(MediaRouter router, RouteInfo info) {
refreshRoute(router);
}
@Override
public void onRouteChanged(MediaRouter router, RouteInfo info) {
refreshRoute(router);
}
private void refreshRoute(MediaRouter router) {
MediaRouteActionProvider provider = mProviderWeak.get();
if (provider != null) {
provider.refreshRoute();
} else {
router.removeCallback(this);
}
}
}
}
|
