Skip to content

Most visited

Recently visited

navigation
AdvancedImmersiveMode / src / com.example.android.advancedimmersivemode /

AdvancedImmersiveModeFragment.java

1
/*
2
* Copyright (C) 2012 The Android Open Source Project
3
*
4
* Licensed under the Apache License, Version 2.0 (the "License");
5
* you may not use this file except in compliance with the License.
6
* You may obtain a copy of the License at
7
*
8
*      http://www.apache.org/licenses/LICENSE-2.0
9
*
10
* Unless required by applicable law or agreed to in writing, software
11
* distributed under the License is distributed on an "AS IS" BASIS,
12
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*/
16
package com.example.android.advancedimmersivemode;
17
 
18
import android.os.Bundle;
19
import android.support.v4.app.Fragment;
20
import android.view.LayoutInflater;
21
import android.view.View;
22
import android.view.ViewGroup;
23
import android.widget.Button;
24
import android.widget.CheckBox;
25
 
26
import com.example.android.common.logger.Log;
27
 
28
/**
29
 * Demonstrates how to update the app's UI by toggling immersive mode.
30
 * Checkboxes are also made available for toggling other UI flags which can
31
 * alter the behavior of immersive mode.
32
 */
33
public class AdvancedImmersiveModeFragment extends Fragment {
34
 
35
    public static final String TAG = "AdvancedImmersiveModeFragment";
36
    public CheckBox mHideNavCheckbox;
37
    public CheckBox mHideStatusBarCheckBox;
38
    public CheckBox mImmersiveModeCheckBox;
39
    public CheckBox mImmersiveModeStickyCheckBox;
40
    public CheckBox mLowProfileCheckBox;
41
 
42
 
43
    @Override
44
    public void onCreate(Bundle savedInstanceState) {
45
        super.onCreate(savedInstanceState);
46
        setHasOptionsMenu(true);
47
    }
48
 
49
    @Override
50
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle state) {
51
        final View flagsView = inflater.inflate(R.layout.fragment_flags, container, false);
52
        mLowProfileCheckBox = (CheckBox) flagsView.findViewById(R.id.flag_enable_lowprof);
53
        mHideNavCheckbox = (CheckBox) flagsView.findViewById(R.id.flag_hide_navbar);
54
        mHideStatusBarCheckBox = (CheckBox) flagsView.findViewById(R.id.flag_hide_statbar);
55
        mImmersiveModeCheckBox = (CheckBox) flagsView.findViewById(R.id.flag_enable_immersive);
56
        mImmersiveModeStickyCheckBox =
57
                (CheckBox) flagsView.findViewById(R.id.flag_enable_immersive_sticky);
58
 
59
        Button toggleFlagsButton = (Button) flagsView.findViewById(R.id.btn_changeFlags);
60
        toggleFlagsButton.setOnClickListener(new View.OnClickListener() {
61
            @Override
62
            public void onClick(View view) {
63
                toggleUiFlags();
64
            }
65
        });
66
 
67
        Button presetsImmersiveModeButton = (Button) flagsView.findViewById(R.id.btn_immersive);
68
        presetsImmersiveModeButton.setOnClickListener(new View.OnClickListener() {
69
            @Override
70
            public void onClick(View view) {
71
 
73
                // For immersive mode, the FULLSCREEN, HIDE_HAVIGATION and IMMERSIVE
74
                // flags should be set (you can use IMMERSIVE_STICKY instead of IMMERSIVE
75
                // as appropriate for your app).  The LOW_PROFILE flag should be cleared.
76
 
77
                // Immersive mode is primarily for situations where the user will be
78
                // interacting with the screen, like games or reading books.
79
                int uiOptions = flagsView.getSystemUiVisibility();
80
                uiOptions &= ~View.SYSTEM_UI_FLAG_LOW_PROFILE;
81
                uiOptions |= View.SYSTEM_UI_FLAG_FULLSCREEN;
82
                uiOptions |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
83
                uiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE;
84
                uiOptions &= ~View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
85
                flagsView.setSystemUiVisibility(uiOptions);
87
 
88
                dumpFlagStateToLog(uiOptions);
89
 
90
                // The below code just updates the checkboxes to reflect which flags have been set.
91
                mLowProfileCheckBox.setChecked(false);
92
                mHideNavCheckbox.setChecked(true);
93
                mHideStatusBarCheckBox.setChecked(true);
94
                mImmersiveModeCheckBox.setChecked(true);
95
                mImmersiveModeStickyCheckBox.setChecked(false);
96
            }
97
        });
98
 
99
 
100
        Button presetsLeanbackModeButton = (Button) flagsView.findViewById(R.id.btn_leanback);
101
        presetsLeanbackModeButton.setOnClickListener(new View.OnClickListener() {
102
            @Override
103
            public void onClick(View view) {
105
                // For leanback mode, only the HIDE_NAVE and HIDE_STATUSBAR flags
106
                // should be checked.  In this case IMMERSIVE should *not* be set,
107
                // since this mode is left as soon as the user touches the screen.
108
                int uiOptions = flagsView.getSystemUiVisibility();
109
                uiOptions &= ~View.SYSTEM_UI_FLAG_LOW_PROFILE;
110
                uiOptions |= View.SYSTEM_UI_FLAG_FULLSCREEN;
111
                uiOptions |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
112
                uiOptions &= ~View.SYSTEM_UI_FLAG_IMMERSIVE;
113
                uiOptions &= ~View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
114
                flagsView.setSystemUiVisibility(uiOptions);
116
 
117
                dumpFlagStateToLog(uiOptions);
118
 
119
                // The below code just updates the checkboxes to reflect which flags have been set.
120
                mLowProfileCheckBox.setChecked(false);
121
                mHideNavCheckbox.setChecked(true);
122
                mHideStatusBarCheckBox.setChecked(true);
123
                mImmersiveModeCheckBox.setChecked(false);
124
                mImmersiveModeStickyCheckBox.setChecked(false);
125
            }
126
        });
127
 
128
        // Setting these flags makes the content appear under the navigation
129
        // bars, so that showing/hiding the nav bars doesn't resize the content
130
        // window, which can be jarring.
131
        int uiOptions = flagsView.getSystemUiVisibility();
132
        uiOptions |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
133
        uiOptions |= View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
134
        uiOptions |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
135
        flagsView.setSystemUiVisibility(uiOptions);
136
 
137
        return flagsView;
138
    }
139
 
140
    /**
141
     * Helper method to dump flag state to the log.
142
     * @param uiFlags Set of UI flags to inspect
143
     */
144
    public void dumpFlagStateToLog(int uiFlags) {
145
        if ((uiFlags & View.SYSTEM_UI_FLAG_LOW_PROFILE) != 0) {
146
            Log.i(TAG, "SYSTEM_UI_FLAG_LOW_PROFILE is set");
147
        } else {
148
            Log.i(TAG, "SYSTEM_UI_FLAG_LOW_PROFILE is unset");
149
        }
150
 
151
        if ((uiFlags & View.SYSTEM_UI_FLAG_FULLSCREEN) != 0) {
152
            Log.i(TAG, "SYSTEM_UI_FLAG_FULLSCREEN is set");
153
        } else {
154
            Log.i(TAG, "SYSTEM_UI_FLAG_FULLSCREEN is unset");
155
        }
156
 
157
        if ((uiFlags & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0) {
158
            Log.i(TAG, "SYSTEM_UI_FLAG_HIDE_NAVIGATION is set");
159
        } else {
160
            Log.i(TAG, "SYSTEM_UI_FLAG_HIDE_NAVIGATION is unset");
161
        }
162
 
163
        if ((uiFlags & View.SYSTEM_UI_FLAG_IMMERSIVE) != 0) {
164
            Log.i(TAG, "SYSTEM_UI_FLAG_IMMERSIVE is set");
165
        } else {
166
            Log.i(TAG, "SYSTEM_UI_FLAG_IMMERSIVE is unset");
167
        }
168
 
169
        if ((uiFlags & View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY) != 0) {
170
            Log.i(TAG, "SYSTEM_UI_FLAG_IMMERSIVE_STICKY is set");
171
        } else {
172
            Log.i(TAG, "SYSTEM_UI_FLAG_IMMERSIVE_STICKY is unset");
173
        }
174
    }
175
 
176
    /**
177
     * Detects and toggles immersive mode (also known as "hidey bar" mode).
178
     */
179
    public void toggleUiFlags() {
180
 
182
        // The "Decor View" is the parent view of the Activity.  It's also conveniently the easiest
183
        // one to find from within a fragment, since there's a handy helper method to pull it, and
184
        // we don't have to bother with picking a view somewhere deeper in the hierarchy and calling
185
        // "findViewById" on it.
186
        View decorView = getActivity().getWindow().getDecorView();
187
        int uiOptions = decorView.getSystemUiVisibility();
188
        int newUiOptions = uiOptions;
190
 
192
        // Low profile mode doesn't resize the screen at all, but it covers the nav & status bar
193
        // icons with black so they're less distracting.  Unlike "full screen" and "hide nav bar,"
194
        // this mode doesn't interact with immersive mode at all, but it's instructive when running
195
        // this sample to observe the differences in behavior.
196
        if (mLowProfileCheckBox.isChecked()) {
197
            newUiOptions |= View.SYSTEM_UI_FLAG_LOW_PROFILE;
198
        } else {
199
            newUiOptions &= ~View.SYSTEM_UI_FLAG_LOW_PROFILE;
200
        }
202
 
204
        // When enabled, this flag hides non-critical UI, such as the status bar,
205
        // which usually shows notification icons, battery life, etc
206
        // on phone-sized devices.  The bar reappears when the user swipes it down.  When immersive
207
        // mode is also enabled, the app-drawable area expands, and when the status bar is swiped
208
        // down, it appears semi-transparently and slides in over the app, instead of pushing it
209
        // down.
210
        if (mHideStatusBarCheckBox.isChecked()) {
211
            newUiOptions |= View.SYSTEM_UI_FLAG_FULLSCREEN;
212
        } else {
213
            newUiOptions &= ~View.SYSTEM_UI_FLAG_FULLSCREEN;
214
        }
216
 
218
        // When enabled, this flag hides the black nav bar along the bottom,
219
        // where the home/back buttons are.  The nav bar normally instantly reappears
220
        // when the user touches the screen.  When immersive mode is also enabled, the nav bar
221
        // stays hidden until the user swipes it back.
222
        if (mHideNavCheckbox.isChecked()) {
223
            newUiOptions |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
224
        } else {
225
            newUiOptions &= ~View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
226
        }
228
 
230
        // Immersive mode doesn't do anything without at least one of the previous flags
231
        // enabled.  When enabled, it allows the user to swipe the status and/or nav bars
232
        // off-screen.  When the user swipes the bars back onto the screen, the flags are cleared
233
        // and immersive mode is automatically disabled.
234
        if (mImmersiveModeCheckBox.isChecked()) {
235
            newUiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE;
236
        } else {
237
            newUiOptions &= ~View.SYSTEM_UI_FLAG_IMMERSIVE;
238
        }
240
 
242
        // There's actually two forms of immersive mode, normal and "sticky".  Sticky immersive mode
243
        // is different in 2 key ways:
244
        //
245
        // * Uses semi-transparent bars for the nav and status bars
246
        // * This UI flag will *not* be cleared when the user interacts with the UI.
247
        //   When the user swipes, the bars will temporarily appear for a few seconds and then
248
        //   disappear again.
249
        if (mImmersiveModeStickyCheckBox.isChecked()) {
250
            newUiOptions |= View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
251
        } else {
252
            newUiOptions &= ~View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;
253
        }
255
 
257
        //Set the new UI flags.
258
        decorView.setSystemUiVisibility(newUiOptions);
260
 
261
        dumpFlagStateToLog(uiOptions);
262
    }
263
}
This site uses cookies to store your preferences for site-specific language and display options.

Hooray!

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a one-minute survey?
Help us improve Android tools and documentation.