VolumeUI.java revision f2565a8b487f6ded259debe33016fc2d896e8681 
1package com.android.systemui.volume;
2
3import android.content.Context;
4import android.content.res.Configuration;
5import android.database.ContentObserver;
6import android.media.AudioManager;
7import android.media.IRemoteVolumeController;
8import android.media.IVolumeController;
9import android.media.session.ISessionController;
10import android.media.session.MediaController;
11import android.media.session.MediaSessionManager;
12import android.net.Uri;
13import android.os.Handler;
14import android.os.RemoteException;
15import android.provider.Settings;
16import android.util.Log;
17
18import com.android.systemui.R;
19import com.android.systemui.SystemUI;
20import com.android.systemui.keyguard.KeyguardViewMediator;
21import com.android.systemui.statusbar.phone.PhoneStatusBar;
22import com.android.systemui.statusbar.policy.ZenModeController;
23import com.android.systemui.statusbar.policy.ZenModeControllerImpl;
24
25import java.io.FileDescriptor;
26import java.io.PrintWriter;
27
28/*
29 * Copyright (C) 2014 The Android Open Source Project
30 *
31 * Licensed under the Apache License, Version 2.0 (the "License");
32 * you may not use this file except in compliance with the License.
33 * You may obtain a copy of the License at
34 *
35 *      http://www.apache.org/licenses/LICENSE-2.0
36 *
37 * Unless required by applicable law or agreed to in writing, software
38 * distributed under the License is distributed on an "AS IS" BASIS,
39 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
40 * See the License for the specific language governing permissions and
41 * limitations under the License.
42 */
43
44public class VolumeUI extends SystemUI {
45    private static final String TAG = "VolumeUI";
46    private static final String SETTING = "systemui_volume_controller";  // for testing
47    private static final Uri SETTING_URI = Settings.Global.getUriFor(SETTING);
48    private static final int DEFAULT = 1;  // enabled by default
49
50    private final Handler mHandler = new Handler();
51
52    private boolean mEnabled;
53    private AudioManager mAudioManager;
54    private MediaSessionManager mMediaSessionManager;
55    private VolumeController mVolumeController;
56    private RemoteVolumeController mRemoteVolumeController;
57
58    private VolumePanel mPanel;
59    private int mDismissDelay;
60
61    @Override
62    public void start() {
63        mEnabled = mContext.getResources().getBoolean(R.bool.enable_volume_ui);
64        if (!mEnabled) return;
65        mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
66        mMediaSessionManager = (MediaSessionManager) mContext
67                .getSystemService(Context.MEDIA_SESSION_SERVICE);
68        initPanel();
69        mVolumeController = new VolumeController();
70        mRemoteVolumeController = new RemoteVolumeController();
71        putComponent(VolumeComponent.class, mVolumeController);
72        updateController();
73        mContext.getContentResolver().registerContentObserver(SETTING_URI, false, mObserver);
74    }
75
76    @Override
77    protected void onConfigurationChanged(Configuration newConfig) {
78        super.onConfigurationChanged(newConfig);
79        if (mPanel != null) {
80            mPanel.onConfigurationChanged(newConfig);
81        }
82    }
83
84    @Override
85    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
86        pw.print("mEnabled="); pw.println(mEnabled);
87        if (mPanel != null) {
88            mPanel.dump(fd, pw, args);
89        }
90    }
91
92    private void updateController() {
93        if (Settings.Global.getInt(mContext.getContentResolver(), SETTING, DEFAULT) != 0) {
94            Log.d(TAG, "Registering volume controller");
95            mAudioManager.setVolumeController(mVolumeController);
96            mMediaSessionManager.setRemoteVolumeController(mRemoteVolumeController);
97        } else {
98            Log.d(TAG, "Unregistering volume controller");
99            mAudioManager.setVolumeController(null);
100            mMediaSessionManager.setRemoteVolumeController(null);
101        }
102    }
103
104    private void initPanel() {
105        mDismissDelay = mContext.getResources().getInteger(R.integer.volume_panel_dismiss_delay);
106        mPanel = new VolumePanel(mContext, new ZenModeControllerImpl(mContext, mHandler));
107        mPanel.setCallback(new VolumePanel.Callback() {
108            @Override
109            public void onZenSettings() {
110                mHandler.removeCallbacks(mStartZenSettings);
111                mHandler.post(mStartZenSettings);
112            }
113
114            @Override
115            public void onInteraction() {
116                final KeyguardViewMediator kvm = getComponent(KeyguardViewMediator.class);
117                if (kvm != null) {
118                    kvm.userActivity();
119                }
120            }
121
122            @Override
123            public void onVisible(boolean visible) {
124                if (mAudioManager != null && mVolumeController != null) {
125                    mAudioManager.notifyVolumeControllerVisible(mVolumeController, visible);
126                }
127            }
128        });
129    }
130
131    private final ContentObserver mObserver = new ContentObserver(mHandler) {
132        public void onChange(boolean selfChange, Uri uri) {
133            if (SETTING_URI.equals(uri)) {
134                updateController();
135            }
136        }
137    };
138
139    private final Runnable mStartZenSettings = new Runnable() {
140        @Override
141        public void run() {
142            getComponent(PhoneStatusBar.class).startActivityDismissingKeyguard(
143                    ZenModePanel.ZEN_SETTINGS, true /* onlyProvisioned */, true /* dismissShade */);
144            mPanel.postDismiss(mDismissDelay);
145        }
146    };
147
148    /** For now, simply host an unmodified base volume panel in this process. */
149    private final class VolumeController extends IVolumeController.Stub implements VolumeComponent {
150
151        @Override
152        public void displaySafeVolumeWarning(int flags) throws RemoteException {
153            mPanel.postDisplaySafeVolumeWarning(flags);
154        }
155
156        @Override
157        public void volumeChanged(int streamType, int flags)
158                throws RemoteException {
159            mPanel.postVolumeChanged(streamType, flags);
160        }
161
162        @Override
163        public void masterVolumeChanged(int flags) throws RemoteException {
164            mPanel.postMasterVolumeChanged(flags);
165        }
166
167        @Override
168        public void masterMuteChanged(int flags) throws RemoteException {
169            mPanel.postMasterMuteChanged(flags);
170        }
171
172        @Override
173        public void setLayoutDirection(int layoutDirection)
174                throws RemoteException {
175            mPanel.postLayoutDirection(layoutDirection);
176        }
177
178        @Override
179        public void dismiss() throws RemoteException {
180            mPanel.postDismiss(0);
181        }
182
183        @Override
184        public ZenModeController getZenController() {
185            return mPanel.getZenController();
186        }
187    }
188
189    private final class RemoteVolumeController extends IRemoteVolumeController.Stub {
190
191        @Override
192        public void remoteVolumeChanged(ISessionController binder, int flags)
193                throws RemoteException {
194            MediaController controller = new MediaController(mContext, binder);
195            mPanel.postRemoteVolumeChanged(controller, flags);
196        }
197
198        @Override
199        public void updateRemoteController(ISessionController session) throws RemoteException {
200            mPanel.postRemoteSliderVisibility(session != null);
201            // TODO stash default session in case the slider can be opened other
202            // than by remoteVolumeChanged.
203        }
204    }
205}
206