use of android.hardware.display.WifiDisplay in project Resurrection_packages_apps_Settings by ResurrectionRemix.
the class WifiDisplaySettings method update.
private void update(int changes) {
boolean invalidateOptions = false;
// Update settings.
if ((changes & CHANGE_SETTINGS) != 0) {
mWifiDisplayOnSetting = Settings.Global.getInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_ON, 0) != 0;
mWifiDisplayCertificationOn = Settings.Global.getInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_CERTIFICATION_ON, 0) != 0;
mWpsConfig = Settings.Global.getInt(getContentResolver(), Settings.Global.WIFI_DISPLAY_WPS_CONFIG, WpsInfo.INVALID);
// The wifi display enabled setting may have changed.
invalidateOptions = true;
}
// Update wifi display state.
if ((changes & CHANGE_WIFI_DISPLAY_STATUS) != 0) {
mWifiDisplayStatus = mDisplayManager.getWifiDisplayStatus();
// The wifi display feature state may have changed.
invalidateOptions = true;
}
// Rebuild the routes.
final PreferenceScreen preferenceScreen = getPreferenceScreen();
preferenceScreen.removeAll();
// Add all known remote display routes.
final int routeCount = mRouter.getRouteCount();
for (int i = 0; i < routeCount; i++) {
MediaRouter.RouteInfo route = mRouter.getRouteAt(i);
if (route.matchesTypes(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY)) {
preferenceScreen.addPreference(createRoutePreference(route));
}
}
// Additional features for wifi display routes.
if (mWifiDisplayStatus != null && mWifiDisplayStatus.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) {
// Add all unpaired wifi displays.
for (WifiDisplay display : mWifiDisplayStatus.getDisplays()) {
if (!display.isRemembered() && display.isAvailable() && !display.equals(mWifiDisplayStatus.getActiveDisplay())) {
preferenceScreen.addPreference(new UnpairedWifiDisplayPreference(getPrefContext(), display));
}
}
// Add the certification menu if enabled in developer options.
if (mWifiDisplayCertificationOn) {
buildCertificationMenu(preferenceScreen);
}
}
// Invalidate menu options if needed.
if (invalidateOptions) {
getActivity().invalidateOptionsMenu();
}
}
use of android.hardware.display.WifiDisplay in project android_frameworks_base by crdroidandroid.
the class WifiDisplayAdapter method updateDisplaysLocked.
private void updateDisplaysLocked() {
List<WifiDisplay> displays = new ArrayList<WifiDisplay>(mAvailableDisplays.length + mRememberedDisplays.length);
boolean[] remembered = new boolean[mAvailableDisplays.length];
for (WifiDisplay d : mRememberedDisplays) {
boolean available = false;
for (int i = 0; i < mAvailableDisplays.length; i++) {
if (d.equals(mAvailableDisplays[i])) {
remembered[i] = available = true;
break;
}
}
if (!available) {
displays.add(new WifiDisplay(d.getDeviceAddress(), d.getDeviceName(), d.getDeviceAlias(), false, false, true));
}
}
for (int i = 0; i < mAvailableDisplays.length; i++) {
WifiDisplay d = mAvailableDisplays[i];
displays.add(new WifiDisplay(d.getDeviceAddress(), d.getDeviceName(), d.getDeviceAlias(), true, d.canConnect(), remembered[i]));
}
mDisplays = displays.toArray(WifiDisplay.EMPTY_ARRAY);
}
use of android.hardware.display.WifiDisplay in project android_frameworks_base by crdroidandroid.
the class WifiDisplayController method updateConnection.
/**
* This function is called repeatedly after each asynchronous operation
* until all preconditions for the connection have been satisfied and the
* connection is established (or not).
*/
private void updateConnection() {
if (DEBUGV) {
//new Throwable("WFD_DBG").printStackTrace();
StackTraceElement[] st = Thread.currentThread().getStackTrace();
for (int i = 2; i < st.length && i < 5; i++) {
Slog.i(TAG, st[i].toString());
}
dump();
}
// Step 0. Stop scans if necessary to prevent interference while connected.
// Resume scans later when no longer attempting to connect.
updateScanState();
// have disconnected from the old one.
if ((mRemoteDisplay != null || mExtRemoteDisplay != null) && (mConnectedDevice != mDesiredDevice) || (mRemoteDisplayInterface != null && mConnectedDevice == null)) {
Slog.i(TAG, "Stopped listening for RTSP connection on " + mRemoteDisplayInterface);
if (mRemoteDisplay != null) {
mRemoteDisplay.dispose();
} else if (mExtRemoteDisplay != null) {
ExtendedRemoteDisplayHelper.dispose(mExtRemoteDisplay);
}
mExtRemoteDisplay = null;
mRemoteDisplay = null;
mRemoteDisplayInterface = null;
mHandler.removeCallbacks(mRtspTimeout);
mWifiP2pManager.setMiracastMode(WifiP2pManager.MIRACAST_DISABLED);
unadvertiseDisplay();
// continue to next step
}
// Step 2. Before we try to connect to a new device, disconnect from the old one.
if (mRemoteDisplayConnected || mDisconnectingDevice != null) {
// wait for asynchronous callback
return;
}
if (mConnectedDevice != null && mConnectedDevice != mDesiredDevice) {
Slog.i(TAG, "Disconnecting from Wifi display: " + mConnectedDevice.deviceName);
mDisconnectingDevice = mConnectedDevice;
mConnectedDevice = null;
mConnectedDeviceGroupInfo = null;
unadvertiseDisplay();
final WifiP2pDevice oldDevice = mDisconnectingDevice;
mWifiP2pManager.removeGroup(mWifiP2pChannel, new ActionListener() {
@Override
public void onSuccess() {
Slog.i(TAG, "Disconnected from Wifi display: " + oldDevice.deviceName);
next();
}
@Override
public void onFailure(int reason) {
Slog.i(TAG, "Failed to disconnect from Wifi display: " + oldDevice.deviceName + ", reason=" + reason);
next();
}
private void next() {
if (mDisconnectingDevice == oldDevice) {
mDisconnectingDevice = null;
updateConnection();
}
}
});
// wait for asynchronous callback
return;
}
// to the old one.
if (mCancelingDevice != null) {
// wait for asynchronous callback
return;
}
if (mConnectingDevice != null && mConnectingDevice != mDesiredDevice) {
Slog.i(TAG, "Canceling connection to Wifi display: " + mConnectingDevice.deviceName);
mCancelingDevice = mConnectingDevice;
mConnectingDevice = null;
unadvertiseDisplay();
mHandler.removeCallbacks(mConnectionTimeout);
final WifiP2pDevice oldDevice = mCancelingDevice;
mWifiP2pManager.cancelConnect(mWifiP2pChannel, new ActionListener() {
@Override
public void onSuccess() {
Slog.i(TAG, "Canceled connection to Wifi display: " + oldDevice.deviceName);
next();
}
@Override
public void onFailure(int reason) {
Slog.i(TAG, "Failed to cancel connection to Wifi display: " + oldDevice.deviceName + ", reason=" + reason);
next();
}
private void next() {
if (mCancelingDevice == oldDevice) {
mCancelingDevice = null;
updateConnection();
}
}
});
// wait for asynchronous callback
return;
}
// autonomous GO, then mission accomplished.
if (mDesiredDevice == null) {
if (mWifiDisplayCertMode) {
mListener.onDisplaySessionInfo(getSessionInfo(mConnectedDeviceGroupInfo, 0));
}
unadvertiseDisplay();
// done
return;
}
//Before we connect, we need to set the oldDevice to the desiredDevice to check
//the device on receiving callbacks from the Remote display modules
final WifiP2pDevice oldDevice = mDesiredDevice;
RemoteDisplay.Listener listener = new RemoteDisplay.Listener() {
@Override
public void onDisplayConnected(Surface surface, int width, int height, int flags, int session) {
if (mConnectedDevice == oldDevice && !mRemoteDisplayConnected) {
Slog.i(TAG, "Opened RTSP connection with Wifi display: " + mConnectedDevice.deviceName);
mRemoteDisplayConnected = true;
mHandler.removeCallbacks(mRtspTimeout);
if (mWifiDisplayCertMode) {
mListener.onDisplaySessionInfo(getSessionInfo(mConnectedDeviceGroupInfo, session));
}
final WifiDisplay display = createWifiDisplay(mConnectedDevice);
advertiseDisplay(display, surface, width, height, flags);
}
}
@Override
public void onDisplayDisconnected() {
if (mConnectedDevice == oldDevice) {
Slog.i(TAG, "Closed RTSP connection with Wifi display: " + mConnectedDevice.deviceName);
mHandler.removeCallbacks(mRtspTimeout);
mRemoteDisplayConnected = false;
disconnect();
}
}
@Override
public void onDisplayError(int error) {
if (mConnectedDevice == oldDevice) {
Slog.i(TAG, "Lost RTSP connection with Wifi display due to error " + error + ": " + mConnectedDevice.deviceName);
mHandler.removeCallbacks(mRtspTimeout);
handleConnectionFailure(false);
}
}
};
// Step 5. Try to connect.
if (mConnectedDevice == null && mConnectingDevice == null) {
Slog.i(TAG, "Connecting to Wifi display: " + mDesiredDevice.deviceName);
mConnectingDevice = mDesiredDevice;
WifiP2pConfig config = new WifiP2pConfig();
WpsInfo wps = new WpsInfo();
if (mWifiDisplayWpsConfig != WpsInfo.INVALID) {
wps.setup = mWifiDisplayWpsConfig;
} else if (mConnectingDevice.wpsPbcSupported()) {
wps.setup = WpsInfo.PBC;
} else if (mConnectingDevice.wpsDisplaySupported()) {
// We do keypad if peer does display
wps.setup = WpsInfo.KEYPAD;
} else {
wps.setup = WpsInfo.DISPLAY;
}
config.wps = wps;
config.deviceAddress = mConnectingDevice.deviceAddress;
// Helps with STA & P2P concurrency
config.groupOwnerIntent = WifiP2pConfig.MIN_GROUP_OWNER_INTENT;
WifiDisplay display = createWifiDisplay(mConnectingDevice);
advertiseDisplay(display, null, 0, 0, 0);
if (ExtendedRemoteDisplayHelper.isAvailable() && mExtRemoteDisplay == null) {
final int port = getPortNumber(mDesiredDevice);
//IP is superfluous for WFD source, and we don't have one at this stage anyway since
//P2P connection hasn't been established yet
final String iface = "255.255.255.255:" + port;
mRemoteDisplayInterface = iface;
Slog.i(TAG, "Listening for RTSP connection on " + iface + " from Wifi display: " + mDesiredDevice.deviceName);
mExtRemoteDisplay = ExtendedRemoteDisplayHelper.listen(iface, listener, mHandler, mContext);
}
final WifiP2pDevice newDevice = mDesiredDevice;
mWifiP2pManager.connect(mWifiP2pChannel, config, new ActionListener() {
@Override
public void onSuccess() {
// The connection may not yet be established. We still need to wait
// for WIFI_P2P_CONNECTION_CHANGED_ACTION. However, we might never
// get that broadcast, so we register a timeout.
Slog.i(TAG, "Initiated connection to Wifi display: " + newDevice.deviceName);
mHandler.postDelayed(mConnectionTimeout, CONNECTION_TIMEOUT_SECONDS * 1000);
}
@Override
public void onFailure(int reason) {
if (mConnectingDevice == newDevice) {
Slog.i(TAG, "Failed to initiate connection to Wifi display: " + newDevice.deviceName + ", reason=" + reason);
mConnectingDevice = null;
handleConnectionFailure(false);
}
}
});
// wait for asynchronous callback
return;
}
// Step 6. Listen for incoming RTSP connection.
if (mConnectedDevice != null && mRemoteDisplay == null) {
Inet4Address addr = getInterfaceAddress(mConnectedDeviceGroupInfo);
if (addr == null) {
Slog.i(TAG, "Failed to get local interface address for communicating " + "with Wifi display: " + mConnectedDevice.deviceName);
handleConnectionFailure(false);
// done
return;
}
mWifiP2pManager.setMiracastMode(WifiP2pManager.MIRACAST_SOURCE);
final int port = getPortNumber(mConnectedDevice);
final String iface = addr.getHostAddress() + ":" + port;
mRemoteDisplayInterface = iface;
if (!ExtendedRemoteDisplayHelper.isAvailable()) {
Slog.i(TAG, "Listening for RTSP connection on " + iface + " from Wifi display: " + mConnectedDevice.deviceName);
mRemoteDisplay = RemoteDisplay.listen(iface, listener, mHandler, mContext.getOpPackageName());
}
// Use extended timeout value for certification, as some tests require user inputs
int rtspTimeout = mWifiDisplayCertMode ? RTSP_TIMEOUT_SECONDS_CERT_MODE : RTSP_TIMEOUT_SECONDS;
mHandler.postDelayed(mRtspTimeout, rtspTimeout * 1000);
}
}
use of android.hardware.display.WifiDisplay in project android_frameworks_base by crdroidandroid.
the class WifiDisplayController method advertiseDisplay.
private void advertiseDisplay(final WifiDisplay display, final Surface surface, final int width, final int height, final int flags) {
if (!Objects.equal(mAdvertisedDisplay, display) || mAdvertisedDisplaySurface != surface || mAdvertisedDisplayWidth != width || mAdvertisedDisplayHeight != height || mAdvertisedDisplayFlags != flags) {
final WifiDisplay oldDisplay = mAdvertisedDisplay;
final Surface oldSurface = mAdvertisedDisplaySurface;
mAdvertisedDisplay = display;
mAdvertisedDisplaySurface = surface;
mAdvertisedDisplayWidth = width;
mAdvertisedDisplayHeight = height;
mAdvertisedDisplayFlags = flags;
mHandler.post(new Runnable() {
@Override
public void run() {
if (oldSurface != null && surface != oldSurface) {
mListener.onDisplayDisconnected();
} else if (oldDisplay != null && !oldDisplay.hasSameAddress(display)) {
mListener.onDisplayConnectionFailed();
}
if (display != null) {
if (!display.hasSameAddress(oldDisplay)) {
mListener.onDisplayConnecting(display);
} else if (!display.equals(oldDisplay)) {
// The address is the same but some other property such as the
// name must have changed.
mListener.onDisplayChanged(display);
}
if (surface != null && surface != oldSurface) {
mListener.onDisplayConnected(display, surface, width, height, flags);
}
}
}
});
}
}
use of android.hardware.display.WifiDisplay in project android_frameworks_base by crdroidandroid.
the class PersistentDataStore method dump.
public void dump(PrintWriter pw) {
pw.println("PersistentDataStore");
pw.println(" mLoaded=" + mLoaded);
pw.println(" mDirty=" + mDirty);
pw.println(" RememberedWifiDisplays:");
int i = 0;
for (WifiDisplay display : mRememberedWifiDisplays) {
pw.println(" " + i++ + ": " + display);
}
pw.println(" DisplayStates:");
i = 0;
for (Map.Entry<String, DisplayState> entry : mDisplayStates.entrySet()) {
pw.println(" " + i++ + ": " + entry.getKey());
entry.getValue().dump(pw, " ");
}
}
Aggregations