path: root/com/android/clockwork/bluetooth/CompanionProxyShard.java

package com.android.clockwork.bluetooth;

import android.annotation.AnyThread;
import android.annotation.MainThread;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.WorkerThread;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.IBluetooth;
import android.bluetooth.IBluetoothManagerCallback;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.os.ParcelFileDescriptor;
import android.os.ParcelUuid;
import android.os.Process;
import android.os.RemoteException;
import android.util.Log;
import com.android.clockwork.bluetooth.proxy.ProxyServiceManager;
import com.android.clockwork.bluetooth.proxy.WearProxyConstants.Reason;
import com.android.clockwork.common.DebugAssert;
import com.android.clockwork.common.Util;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IndentingPrintWriter;
import java.io.Closeable;
import java.lang.reflect.Method;

/**
 * Manages connections to the companion sysproxy network
 *
 * This class handles connecting to the remote device using the
 * bluetooth network and configuring the sysproxy to setup the
 * proper network to allow IP traffic to be utilized by Android.
 *
 * Steps to connect to the companion sysproxy.
 *
 * 1. Get a bluetooth rfcomm socket.
 *      This will actually establish a bluetooth connection from the device to the companion.
 * 2. Pass this rfcomm socket to the sysproxy module.
 *      The sysproxy module will formulate the necessary network configuration to allow
 *      IP traffic to flow over the bluetooth socket connection.
 * 3. Get acknowledgement that the sysproxy module initialized.
 *      This may or may not be completed successfully as indicated by the jni callback
 *      indicating connection or failure.
 *
 */
public class CompanionProxyShard implements Closeable, ProxyServiceManager.ProxyServiceCallback {
    private static final String TAG = WearBluetoothConstants.LOG_TAG;
    private static final int WHAT_START_SYSPROXY = 1;
    private static final int WHAT_STOP_SYSPROXY = 2;
    private static final int WHAT_JNI_CONNECTED = 3;
    private static final int WHAT_JNI_DISCONNECTED = 4;
    private static final int WHAT_CONNECTION_FAILED = 5;
    private static final int WHAT_RESET_CONNECTION = 6;

    private static final int INVALID_NETWORK_TYPE = -1;
    private static final int TYPE_RFCOMM = 1;
    private static final int SEC_FLAG_ENCRYPT = 1 << 0;
    private static final int SEC_FLAG_AUTH = 1 << 1;
    // Relative unitless network retry values
    private static final int BACKOFF_BASE_INTERVAL = 2;
    private static final int BACKOFF_BASE_PERIOD = 5;
    private static final int BACKOFF_MAX_INTERVAL = 300;
    private static final ParcelUuid PROXY_UUID =
        ParcelUuid.fromString("fafbdd20-83f0-4389-addf-917ac9dae5b2");

    private static int sInstance;
    private final int mInstance;
    private int mStartAttempts;

    static native void classInitNative();
    @VisibleForTesting native boolean connectNative(int fd);
    @VisibleForTesting native boolean disconnectNative();

    static {
        try {
            System.loadLibrary("wear-bluetooth-jni");
            classInitNative();
        } catch (UnsatisfiedLinkError e) {
            // Invoked during testing
            Log.e(TAG, "Unable to load wear bluetooth sysproxy jni native"
                    + " libraries");
        }
    }

    @NonNull private final Context mContext;
    @NonNull private final BluetoothDevice mCompanionDevice;
    @NonNull private final Listener mListener;
    @NonNull private final ProxyServiceManager mProxyServiceManager;

    private final MultistageExponentialBackoff mReconnectBackoff;
    @VisibleForTesting boolean mIsClosed;

    /** State of sysproxy module process
     *
     * This is a static field because the instance gets
     * created and destroyed by the upper layer based upon
     * specific conditions (e.g. GMS core connected or not)
     *
     * As each instance is created the state of the JNI sysproxy
     * is unknown, so the state of the previous instance is kept here.
     */
    @VisibleForTesting
    static enum State {
        SYSPROXY_DISCONNECTED,  // IDLE or JNI callback
        BLUETOOTH_SOCKET_REQUESTING, // Background thread
        BLUETOOTH_SOCKET_RETRIEVED,
        SYSPROXY_SOCKET_DELIVERING, // Background thread
        SYSPROXY_SOCKET_DELIVERED,
        SYSPROXY_CONNECTED, // JNI callback
        SYSPROXY_DISCONNECT_REQUEST,
        SYSPROXY_DISCONNECT_RESPONSE,
    }

    @VisibleForTesting
    static ProxyState mState = new ProxyState(State.SYSPROXY_DISCONNECTED);

    @VisibleForTesting
    static class ProxyState {
        private State mState;

        public ProxyState(final State state) {
            mState = state;
        }

        @MainThread
        public boolean checkState(final State state) {
            DebugAssert.isMainThread();
            return mState == state;
        }

        @MainThread
        public void advanceState(final int instance, final State state) {
            DebugAssert.isMainThread();
            mState = state;
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "CompanionProxyShard [ " + instance + " ] Set new companion proxy"
                        + " state:" + mState);
            }
        }

        @AnyThread
        public State current() {
            return mState;
        }
    }

    /**
     * Callback executed when the sysproxy becomes connected or disconnected
     *
     * This may send duplicate disconnect events, because failed reconnect
     * attempts are indistinguishable from actual disconnects.
     * Listeners should appropriately deduplicate these disconnect events.
     */
    public interface Listener {
        void onProxyConnectionChange(boolean isConnected, int proxyScore);
    }

    public CompanionProxyShard(
            @NonNull final Context context,
            @NonNull final ProxyServiceManager proxyServiceManager,
            @NonNull final BluetoothDevice companionDevice,
            @NonNull final Listener listener) {
            DebugAssert.isMainThread();

            mContext = context;
            mProxyServiceManager = proxyServiceManager;
            mCompanionDevice = companionDevice;
            mListener = listener;

            mProxyServiceManager.setCallback(this);
            mReconnectBackoff = new MultistageExponentialBackoff(BACKOFF_BASE_INTERVAL,
                    BACKOFF_BASE_PERIOD, BACKOFF_MAX_INTERVAL);

            mInstance = sInstance++;
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Created companion proxy"
                        + " shard");
            }
        }

    /** Completely shuts down companion proxy network */
    @MainThread
    @Override  // Closable
    public void close() {
        DebugAssert.isMainThread();
        if (mIsClosed) {
            Log.w(TAG, "CompanionProxyShard [ " + mInstance + " ] Already closed");
            return;
        }
        mProxyServiceManager.setCallback(null);
        disconnectAndNotify(Reason.CLOSABLE);
        // notify mListeners of our intended disconnect before setting mIsClosed to true
        mIsClosed = true;
        disconnectNativeInBackground();
        mHandler.removeMessages(WHAT_START_SYSPROXY);
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Closed companion proxy shard");
        }
    }

    @MainThread
    @Override  // ProxyServiceManager.ProxyServiceCallback
    public void onStartNetwork() {
        DebugAssert.isMainThread();
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] onStartNetwork()");
        }
        mHandler.sendEmptyMessage(WHAT_START_SYSPROXY);
    }

    @MainThread
    @Override   // ProxyServiceManager.ProxyServiceCallback
    public void onStopNetwork() {
        DebugAssert.isMainThread();
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] onStopNetwork()");
        }
        mHandler.sendEmptyMessage(WHAT_STOP_SYSPROXY);
    }

    @MainThread
    @Override   // ProxyServiceManager.ProxyServiceCallback
    public void onUpdateNetwork(int networkScore) {
        DebugAssert.isMainThread();
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] onUpdateNetwork()");

        }
    }

    /** Serialize state change requests here */
    @VisibleForTesting
    final Handler mHandler = new Handler() {
        @MainThread
        @Override
        public void handleMessage(Message msg) {
            DebugAssert.isMainThread();
            switch (msg.what) {
                case WHAT_START_SYSPROXY:
                    mStartAttempts++;
                    mHandler.removeMessages(WHAT_START_SYSPROXY);
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Request to start"
                                + " companion sysproxy network");
                    }
                    if (mState.checkState(State.SYSPROXY_CONNECTED)) {
                        if (Log.isLoggable(TAG, Log.DEBUG)) {
                            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] companion proxy"
                                    + " network already running set connected");
                        }
                        mProxyServiceManager.ensureValidNetworkAgent("Already Connected");
                        connectAndNotify(Reason.SYSPROXY_WAS_CONNECTED);
                    } else if (mState.checkState(State.SYSPROXY_DISCONNECTED)) {
                        if (Log.isLoggable(TAG, Log.DEBUG)) {
                            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] companion proxy"
                                    + " network starting up sysproxy module state:"
                                    + mState.current());
                        }
                        mProxyServiceManager.ensureValidNetworkAgent(Reason.START_SYSPROXY);
                        getBluetoothSocket();
                    } else {
                        final int nextRetry = mReconnectBackoff.getNextBackoff();
                        Log.w(TAG, "CompanionProxyShard [ " + mInstance + " ] network not"
                                + " idle/disconnected state:" + mState.current()
                                + " attempting reconnect in " + nextRetry + " seconds");
                        mHandler.sendEmptyMessageDelayed(WHAT_START_SYSPROXY, nextRetry * 1000);
                    }
                    break;
                case WHAT_STOP_SYSPROXY:
                    // If not closed from the upper layer, the proxy will always try maintain a
                    // connection.  However, when the connectivity service decides this network
                    // is unwanted we must break down the current network agent and re-attach
                    // launch with a new network agent.
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Stop companion proxy"
                                + " network");
                    }
                    if (mState.checkState(State.SYSPROXY_CONNECTED)) {
                        disconnectAndNotify(Reason.STOP_SYSPROXY);
                    } else {
                        Log.w(TAG, "CompanionProxyShard [ " + mInstance + " ] companion proxy"
                                + " network not connected! state:" + mState.current());
                    }
                    break;
                case WHAT_JNI_CONNECTED:
                    mReconnectBackoff.reset();
                    mState.advanceState(mInstance, State.SYSPROXY_CONNECTED);
                    break;
                case WHAT_JNI_DISCONNECTED:
                    final int status = msg.arg1;
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI onDisconnect"
                                + " sysproxy closed mIsClosed:" + mIsClosed + " status:" + status);
                    }
                    if (!mIsClosed && mState.current() != State.SYSPROXY_DISCONNECTED) {
                        disconnectAndNotify(Reason.SYSPROXY_DISCONNECTED);
                        setUpRetry();
                    }
                    mState.advanceState(mInstance, State.SYSPROXY_DISCONNECTED);
                    break;
                case WHAT_CONNECTION_FAILED:
                    if (mState.checkState(State.SYSPROXY_CONNECTED)) {
                        Log.e(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI sysproxy failed"
                                + " state:" + mState.current());
                    } else {
                        Log.e(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI sysproxy unable"
                                + " to connect state:" + mState.current());
                    }
                    // fall through
                case WHAT_RESET_CONNECTION:
                    // Take a hammer to reset everything on sysproxy side to initial state.
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Reset companion proxy"
                                + " network connection last state:" + mState.current()
                                + " isClosed:" + mIsClosed);
                    }
                    mHandler.removeMessages(WHAT_START_SYSPROXY);
                    mHandler.removeMessages(WHAT_RESET_CONNECTION);
                    disconnectNativeInBackground();
                    setUpRetry();
                    break;
            }
        }
    };

    private void setUpRetry() {
        // Setup a reconnect sequence if shard has not been closed.
        if (!mIsClosed) {
            final int nextRetry = mReconnectBackoff.getNextBackoff();
            mHandler.sendEmptyMessageDelayed(WHAT_START_SYSPROXY, nextRetry * 1000);
            Log.w(TAG, "CompanionProxyShard [ " + mInstance + " ] Proxy reset"
                    + " Attempting reconnect in " + nextRetry + " seconds");
        }
    }

    /** Use binder API to directly request rfcomm socket from bluetooth module */
    @MainThread
    private void getBluetoothSocket() {
        DebugAssert.isMainThread();

        mState.advanceState(mInstance, State.BLUETOOTH_SOCKET_REQUESTING);
        mProxyServiceManager.setConnecting(Reason.REQUEST_BT_SOCKET);
        if (Log.isLoggable(TAG, Log.DEBUG)) {
            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Retrieving bluetooth network"
                    + " socket");
        }

        new DefaultPriorityAsyncTask<Void, Void, ParcelFileDescriptor>() {
            @Override
            protected ParcelFileDescriptor doInBackgroundDefaultPriority() {
                try {
                    final IBluetooth bluetoothProxy = getBluetoothService(mInstance);
                    if (bluetoothProxy == null) {
                        Log.e(TAG, "CompanionProxyShard [ " + mInstance + " ] Unable to get binder"
                                + " proxy to IBluetooth");
                        return null;
                    }
                    ParcelFileDescriptor parcelFd = bluetoothProxy.getSocketManager().connectSocket(
                            mCompanionDevice,
                            TYPE_RFCOMM,
                            PROXY_UUID,
                            0 /* port */,
                            SEC_FLAG_AUTH | SEC_FLAG_ENCRYPT
                            );

                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] parcelFd:"
                                + parcelFd);
                    }

                    return parcelFd;
                } catch (RemoteException e) {
                    Log.e(TAG, "CompanionProxyShard [ " + mInstance + " ] Unable to get bluetooth"
                            + " service", e);
                    return null;
                }
            }

            @Override
            protected void onPostExecute(@Nullable ParcelFileDescriptor parcelFd) {
                DebugAssert.isMainThread();

                if (mIsClosed) {
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Shard closed after"
                                + " retrieving bluetooth socket");
                    }
                    return;
                } else if (parcelFd != null) {
                    if (!mState.checkState(State.BLUETOOTH_SOCKET_REQUESTING)) {
                        if (Log.isLoggable(TAG, Log.DEBUG)) {
                            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] unexpected state"
                                    + " after retrieving bluetooth network socket state:"
                                    + mState.current());
                        }
                    } else {
                        mState.advanceState(mInstance, State.BLUETOOTH_SOCKET_RETRIEVED);
                        final int fd = parcelFd.detachFd();
                        if (Log.isLoggable(TAG, Log.DEBUG)) {
                            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Retrieved"
                                    + " bluetooth network socket state:" + mState.current()
                                    + " parcelFd:" + parcelFd + " fd:" + fd);
                        }
                        connectNativeInBackground(fd);
                    }
                } else {
                    Log.e(TAG, "CompanionProxyShard [ " + mInstance + " ] Unable to request"
                            + "bluetooth network socket");
                    mHandler.sendEmptyMessage(WHAT_RESET_CONNECTION);
                }
                Util.close(parcelFd);
            }
        }.execute();
    }

    @MainThread
    private void connectNativeInBackground(Integer fd) {
        DebugAssert.isMainThread();
        mState.advanceState(mInstance, State.SYSPROXY_SOCKET_DELIVERING);
        mProxyServiceManager.setConnecting(Reason.DELIVER_BT_SOCKET);

        new ConnectSocketAsyncTask() {
            @Override
            protected Boolean doInBackgroundDefaultPriority(Integer fileDescriptor) {
                Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
                final int fd = fileDescriptor.intValue();
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] connectNativeInBackground"
                            + " state:" + mState.current() + " fd:" + fd);
                }
                final boolean rc = connectNative(fd);
                return new Boolean(rc);
            }

            @Override
            protected void onPostExecute(Boolean result) {
                DebugAssert.isMainThread();
                if (mIsClosed) {
                    if (Log.isLoggable(TAG, Log.DEBUG)) {
                        Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] Shard closed after"
                                + "sending bluetooth socket");
                    }
                    return;
                }
                if (result) {
                    if (!mState.checkState(State.SYSPROXY_SOCKET_DELIVERING)) {
                        if (Log.isLoggable(TAG, Log.DEBUG)) {
                            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] unexpected state"
                                    + " after delivering socket state:" + mState.current()
                                    + " fd:" + fd);
                        }
                    } else {
                        mState.advanceState(mInstance, State.SYSPROXY_SOCKET_DELIVERED);
                        if (Log.isLoggable(TAG, Log.DEBUG)) {
                            Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] proxy socket"
                                    + " delivered state:" + mState.current() + " fd:" + fd);
                        }
                    }
                } else {
                    Log.w(TAG, "CompanionProxyShard [ " + mInstance + " ] Unable to deliver socket"
                            + " to sysproxy module");
                    mHandler.sendEmptyMessage(WHAT_RESET_CONNECTION);
                }
            }
        }.execute(fd);
    }

    /** This call should be idempotent to always ensure proper initial state */
    @MainThread
    private void disconnectNativeInBackground() {
        DebugAssert.isMainThread();
        if (mState.checkState(State.SYSPROXY_DISCONNECTED)) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI has already"
                        + " disconnected");
            }
            return;
        }

        mState.advanceState(mInstance, State.SYSPROXY_DISCONNECT_REQUEST);
        new DefaultPriorityAsyncTask<Void, Void, Boolean>() {
            @Override
            protected Boolean doInBackgroundDefaultPriority() {
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI Disconnect request to"
                            + " sysproxy module");
                }
                return disconnectNative();
            }

            @MainThread
            @Override
            protected void onPostExecute(Boolean result) {
                DebugAssert.isMainThread();
                if (result) {
                    mState.advanceState(mInstance, State.SYSPROXY_DISCONNECT_RESPONSE);
                } else {
                    mState.advanceState(mInstance, State.SYSPROXY_DISCONNECTED);
                }
                if (Log.isLoggable(TAG, Log.DEBUG)) {
                    Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI Disconnect response"
                            + " result:" + result + " mIsClosed:" + mIsClosed);
                }
            }
        }.execute();
    }

    /**
     * This method is called from JNI in a background thread when the companion proxy
     * network state changes on the phone.
     */
    @WorkerThread
    protected void onActiveNetworkState(final int networkType, final boolean isMetered) {
        if (mIsClosed) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI onActiveNetworkState"
                        + " shard closed...bailing");
            }
            return;
        }

        if (networkType == INVALID_NETWORK_TYPE) {
            mHandler.sendEmptyMessage(WHAT_CONNECTION_FAILED);
        } else {
            connectAndNotify(Reason.SYSPROXY_CONNECTED);
            mProxyServiceManager.setMetered(isMetered);
            mHandler.sendEmptyMessage(WHAT_JNI_CONNECTED);
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "CompanionProxyShard [ " + mInstance + " ] JNI sysproxy process complete"
                        + " state:" + mState.current() + " networkType:" + networkType + " metered:"
                        + isMetered);
            }
        }
    }

    /** This method is called from JNI in a background thread when the proxy has disconnected. */
    @WorkerThread
    protected void onDisconnect(int status) {
        mHandler.sendMessage(mHandler.obtainMessage(WHAT_JNI_DISCONNECTED, status, 0));
    }

    /**
     * These methods notify connectivity service and the upper layers
     * with the current sysproxy state.
     */
    @AnyThread
    private void connectAndNotify(final String reason) {
        mProxyServiceManager.setConnected(reason);
        notifyConnectionChange(true);
    }

    @AnyThread
    private void disconnectAndNotify(final String reason) {
        mProxyServiceManager.setDisconnected(reason);
        notifyConnectionChange(false);
    }

    /**
     * This method notifies mListeners about the state of the sysproxy network.
     *
     *  NOTE: CompanionProxyShard should never call onProxyConnectionChange directly!
     *       Use the notifyConnectionChange method instead.
     */
    @AnyThread
    private void notifyConnectionChange(final boolean isConnected) {
        if (!mIsClosed) {
            mListener.onProxyConnectionChange(isConnected, mProxyServiceManager.getNetworkScore());
        }
    }

    private abstract static class DefaultPriorityAsyncTask<Params, Progress, Result>
            extends AsyncTask<Params, Progress, Result> {

            @Override
            protected Result doInBackground(Params... params) {
                Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
                return doInBackgroundDefaultPriority();
            }

            protected abstract Result doInBackgroundDefaultPriority();
    }

    private abstract static class ConnectSocketAsyncTask extends AsyncTask<Integer, Void, Boolean> {
        @Override
        protected Boolean doInBackground(Integer... params) {
            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
            final Integer fileDescriptor = params[0];
            return doInBackgroundDefaultPriority(fileDescriptor);
        }

        protected abstract Boolean doInBackgroundDefaultPriority(Integer fd);
    }

    /** Returns the shared instance of IBluetooth using reflection (method is package private). */
    private static IBluetooth getBluetoothService(final int instance) {
        try {
            final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
            final Method getBluetoothService = adapter.getClass()
                .getDeclaredMethod("getBluetoothService", IBluetoothManagerCallback.class);
            getBluetoothService.setAccessible(true);
            return (IBluetooth) getBluetoothService.invoke(adapter, new Object[] { null });
        } catch (Exception e) {
            Log.e(TAG, "CompanionProxyShard [ " + instance + " ] Error retrieving IBluetooth: ", e);
            return null;
        }
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        result.append("CompanionProxyShard: " + mInstance);
        return result.toString();
    }

    public void dump(@NonNull final IndentingPrintWriter ipw) {
        ipw.printf("Companion proxy instance:%d companion device:%s\n", mInstance,
                mCompanionDevice);
        ipw.increaseIndent();
        ipw.printPair("Current state", mState.current());
        ipw.printPair("Is closed", mIsClosed);
        ipw.printPair("Start attempts", mStartAttempts);
        ipw.printPair("Start connection scheduled",
                mHandler.hasMessages(WHAT_START_SYSPROXY));
        ipw.println();
        ipw.decreaseIndent();
        mProxyServiceManager.dump(ipw);
    }
}