Examples with StackTraceElement java.lang.StackTraceElement used on opensource projects

Example 1 with StackTraceElement

use of java.lang.StackTraceElement in project android_frameworks_base by ResurrectionRemix.

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);
    }
}

Example 2 with StackTraceElement

use of java.lang.StackTraceElement in project brisk by riptano.

the class ThriftUtils method toThrift.

public static IOException toThrift(Throwable t) {
    if (t == null) {
        return new IOException();
    }
    IOException ret = new IOException();
    ret.clazz = t.getClass().getName();
    ret.msg = t.getMessage();
    ret.stack = "";
    for (StackTraceElement frame : t.getStackTrace()) {
        ret.stack += frame.toString() + "\n";
    }
    return ret;
}

Example 3 with StackTraceElement

use of java.lang.StackTraceElement in project android_frameworks_base by AOSPA.

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);
    }
}

Example 4 with StackTraceElement

use of java.lang.StackTraceElement 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);
    }
}