xref: /frameworks/base/tests/RemoteDisplayProvider/src/com/android/media/remotedisplay/test/RemoteDisplayProviderService.java

/*
 * Copyright (C) 2013 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 com.android.media.remotedisplay.test;

import com.android.media.remotedisplay.RemoteDisplay;
import com.android.media.remotedisplay.RemoteDisplayProvider;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.util.Log;

/**
 * Remote display provider implementation that publishes working routes.
 */
public class RemoteDisplayProviderService extends Service {
    private static final String TAG = "RemoteDisplayProviderTest";

    private Provider mProvider;

    @Override
    public IBinder onBind(Intent intent) {
        if (intent.getAction().equals(RemoteDisplayProvider.SERVICE_INTERFACE)) {
            if (mProvider == null) {
                mProvider = new Provider();
                return mProvider.getBinder();
            }
        }
        return null;
    }

    final class Provider extends RemoteDisplayProvider {
        private RemoteDisplay mTestDisplay1; // variable volume
        private RemoteDisplay mTestDisplay2; // fixed volume
        private RemoteDisplay mTestDisplay3; // not available
        private RemoteDisplay mTestDisplay4; // in use
        private RemoteDisplay mTestDisplay5; // available but ignores request to connect
        private RemoteDisplay mTestDisplay6; // available but never finishes connecting
        private RemoteDisplay mTestDisplay7; // blinks in and out of existence
        private RemoteDisplay mTestDisplay8; // available but connecting attempt flakes out
        private RemoteDisplay mTestDisplay9; // available but connection flakes out
        private RemoteDisplay mTestDisplay10; // available and reconnects periodically

        private final Handler mHandler;
        private boolean mBlinking;

        public Provider() {
            super(RemoteDisplayProviderService.this);
            mHandler = new Handler(getMainLooper());
        }

        @Override
        public void onDiscoveryModeChanged(int mode) {
            Log.d(TAG, "onDiscoveryModeChanged: mode=" + mode);

            if (mode != DISCOVERY_MODE_NONE) {
                // When discovery begins, go find all of the routes.
                if (mTestDisplay1 == null) {
                    mTestDisplay1 = new RemoteDisplay("testDisplay1",
                            "Test Display 1 (variable)");
                    mTestDisplay1.setDescription("Variable volume");
                    mTestDisplay1.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    mTestDisplay1.setVolume(10);
                    mTestDisplay1.setVolumeHandling(RemoteDisplay.PLAYBACK_VOLUME_VARIABLE);
                    mTestDisplay1.setVolumeMax(15);
                    addDisplay(mTestDisplay1);
                }
                if (mTestDisplay2 == null) {
                    mTestDisplay2 = new RemoteDisplay("testDisplay2",
                            "Test Display 2 (fixed)");
                    mTestDisplay2.setDescription("Fixed volume");
                    mTestDisplay2.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    addDisplay(mTestDisplay2);
                }
                if (mTestDisplay3 == null) {
                    mTestDisplay3 = new RemoteDisplay("testDisplay3",
                            "Test Display 3 (unavailable)");
                    mTestDisplay3.setDescription("Always unavailable");
                    mTestDisplay3.setStatus(RemoteDisplay.STATUS_NOT_AVAILABLE);
                    addDisplay(mTestDisplay3);
                }
                if (mTestDisplay4 == null) {
                    mTestDisplay4 = new RemoteDisplay("testDisplay4",
                            "Test Display 4 (in-use)");
                    mTestDisplay4.setDescription("Always in-use");
                    mTestDisplay4.setStatus(RemoteDisplay.STATUS_IN_USE);
                    addDisplay(mTestDisplay4);
                }
                if (mTestDisplay5 == null) {
                    mTestDisplay5 = new RemoteDisplay("testDisplay5",
                            "Test Display 5 (connect ignored)");
                    mTestDisplay5.setDescription("Ignores connect");
                    mTestDisplay5.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    addDisplay(mTestDisplay5);
                }
                if (mTestDisplay6 == null) {
                    mTestDisplay6 = new RemoteDisplay("testDisplay6",
                            "Test Display 6 (connect hangs)");
                    mTestDisplay6.setDescription("Never finishes connecting");
                    mTestDisplay6.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    addDisplay(mTestDisplay6);
                }
                if (mTestDisplay8 == null) {
                    mTestDisplay8 = new RemoteDisplay("testDisplay8",
                            "Test Display 8 (flaky when connecting)");
                    mTestDisplay8.setDescription("Aborts spontaneously while connecting");
                    mTestDisplay8.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    addDisplay(mTestDisplay8);
                }
                if (mTestDisplay9 == null) {
                    mTestDisplay9 = new RemoteDisplay("testDisplay9",
                            "Test Display 9 (flaky when connected)");
                    mTestDisplay9.setDescription("Aborts spontaneously while connected");
                    mTestDisplay9.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    addDisplay(mTestDisplay9);
                }
                if (mTestDisplay10 == null) {
                    mTestDisplay10 = new RemoteDisplay("testDisplay10",
                            "Test Display 10 (reconnects periodically)");
                    mTestDisplay10.setDescription("Reconnects spontaneously");
                    mTestDisplay10.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                    addDisplay(mTestDisplay10);
                }
            } else {
                // When discovery ends, go hide some of the routes we can't actually use.
                // This isn't something a normal route provider would do though.
                // The routes will usually stay published.
                if (mTestDisplay3 != null) {
                    removeDisplay(mTestDisplay3);
                    mTestDisplay3 = null;
                }
                if (mTestDisplay4 != null) {
                    removeDisplay(mTestDisplay4);
                    mTestDisplay4 = null;
                }
            }

            // When active discovery is on, pretend there's a route that we can't quite
            // reach that blinks in and out of existence.
            if (mode == DISCOVERY_MODE_ACTIVE) {
                if (!mBlinking) {
                    mBlinking = true;
                    mHandler.post(mBlink);
                }
            } else {
                mBlinking = false;
            }
        }

        @Override
        public void onConnect(final RemoteDisplay display) {
            Log.d(TAG, "onConnect: display.getId()=" + display.getId());

            if (display == mTestDisplay1 || display == mTestDisplay2) {
                display.setStatus(RemoteDisplay.STATUS_CONNECTING);
                updateDisplay(display);
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        if ((display == mTestDisplay1 || display == mTestDisplay2)
                                && display.getStatus() == RemoteDisplay.STATUS_CONNECTING) {
                            display.setStatus(RemoteDisplay.STATUS_CONNECTED);
                            updateDisplay(display);
                        }
                    }
                }, 2000);
            } else if (display == mTestDisplay6 || display == mTestDisplay7) {
                // never finishes connecting
                display.setStatus(RemoteDisplay.STATUS_CONNECTING);
                updateDisplay(display);
            } else if (display == mTestDisplay8) {
                // flakes out while connecting
                display.setStatus(RemoteDisplay.STATUS_CONNECTING);
                updateDisplay(display);
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        if ((display == mTestDisplay8)
                                && display.getStatus() == RemoteDisplay.STATUS_CONNECTING) {
                            display.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                            updateDisplay(display);
                        }
                    }
                }, 2000);
            } else if (display == mTestDisplay9) {
                // flakes out when connected
                display.setStatus(RemoteDisplay.STATUS_CONNECTING);
                updateDisplay(display);
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        if ((display == mTestDisplay9)
                                && display.getStatus() == RemoteDisplay.STATUS_CONNECTING) {
                            display.setStatus(RemoteDisplay.STATUS_CONNECTED);
                            updateDisplay(display);
                        }
                    }
                }, 2000);
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        if ((display == mTestDisplay9)
                                && display.getStatus() == RemoteDisplay.STATUS_CONNECTED) {
                            display.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                            updateDisplay(display);
                        }
                    }
                }, 5000);
            } else if (display == mTestDisplay10) {
                display.setStatus(RemoteDisplay.STATUS_CONNECTING);
                updateDisplay(display);
                mHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        if (display == mTestDisplay10) {
                            if (display.getStatus() == RemoteDisplay.STATUS_CONNECTING) {
                                display.setStatus(RemoteDisplay.STATUS_CONNECTED);
                                updateDisplay(display);
                                mHandler.postDelayed(this, 7000);
                            } else if (display.getStatus() == RemoteDisplay.STATUS_CONNECTED) {
                                display.setStatus(RemoteDisplay.STATUS_CONNECTING);
                                updateDisplay(display);
                                mHandler.postDelayed(this, 2000);
                            }
                        }
                    }
                }, 2000);
            }
        }

        @Override
        public void onDisconnect(RemoteDisplay display) {
            Log.d(TAG, "onDisconnect: display.getId()=" + display.getId());

            if (display == mTestDisplay1 || display == mTestDisplay2
                    || display == mTestDisplay6 || display == mTestDisplay8
                    || display == mTestDisplay9 || display == mTestDisplay10) {
                display.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                updateDisplay(display);
            }
        }

        @Override
        public void onSetVolume(RemoteDisplay display, int volume) {
            Log.d(TAG, "onSetVolume: display.getId()=" + display.getId()
                    + ", volume=" + volume);

            if (display == mTestDisplay1) {
                display.setVolume(Math.max(0, Math.min(display.getVolumeMax(), volume)));
                updateDisplay(display);
            }
        }

        @Override
        public void onAdjustVolume(RemoteDisplay display, int delta) {
            Log.d(TAG, "onAdjustVolume: display.getId()=" + display.getId()
                    + ", delta=" + delta);

            if (display == mTestDisplay1) {
                display.setVolume(Math.max(0, Math.min(display.getVolumeMax(),
                        display .getVolume() + delta)));
                updateDisplay(display);
            }
        }

        @Override
        public void addDisplay(RemoteDisplay display) {
            Log.d(TAG, "addDisplay: display=" + display);
            super.addDisplay(display);
        }

        @Override
        public void removeDisplay(RemoteDisplay display) {
            Log.d(TAG, "removeDisplay: display=" + display);
            super.removeDisplay(display);
        }

        @Override
        public void updateDisplay(RemoteDisplay display) {
            Log.d(TAG, "updateDisplay: display=" + display);
            super.updateDisplay(display);
        }

        private final Runnable mBlink = new Runnable() {
            @Override
            public void run() {
                if (mTestDisplay7 == null) {
                    if (mBlinking) {
                        mTestDisplay7 = new RemoteDisplay("testDisplay7",
                                "Test Display 7 (blinky)");
                        mTestDisplay7.setDescription("Comes and goes but can't connect");
                        mTestDisplay7.setStatus(RemoteDisplay.STATUS_AVAILABLE);
                        addDisplay(mTestDisplay7);
                        mHandler.postDelayed(this, 7000);
                    }
                } else {
                    removeDisplay(mTestDisplay7);
                    mTestDisplay7 = null;
                    if (mBlinking) {
                        mHandler.postDelayed(this, 4000);
                    }
                }
            }
        };
    }
}