Java Code Examples for android.content.pm.ActivityInfo#SCREEN_ORIENTATION_UNSPECIFIED

@Override
protected void onStart() {
	super.onStart();

	// set the video player's orientation as what the user wants
	String  str = SkyTubeApp.getPreferenceManager().getString(getString(R.string.pref_key_screen_orientation), getString(R.string.pref_screen_auto_value));
	int     orientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;

	if (str.equals(getString(R.string.pref_screen_landscape_value)))
		orientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
	if (str.equals(getString(R.string.pref_screen_portrait_value)))
		orientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT;
	if (str.equals(getString(R.string.pref_screen_sensor_value)))
		orientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR;

	setRequestedOrientation(orientation);
}
 

private void onActivityCreated(Activity activity) throws RemoteException {
    try {
        Intent targetIntent = activity.getIntent();
        if (targetIntent != null) {
            ActivityInfo targetInfo = targetIntent.getParcelableExtra(Env.EXTRA_TARGET_INFO);
            ActivityInfo stubInfo = targetIntent.getParcelableExtra(Env.EXTRA_STUB_INFO);
            if (targetInfo != null && stubInfo != null) {
                RunningActivities.onActivtyCreate(activity, targetInfo, stubInfo);
                if (activity.getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
                        && targetInfo.screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
                    activity.setRequestedOrientation(targetInfo.screenOrientation);
                }
                PluginManager.getInstance().onActivityCreated(stubInfo, targetInfo);
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                    fixTaskDescription(activity, targetInfo);
                }
            }
        }
    } catch (Exception e) {
        Log.i(TAG, "onActivityCreated fail", e);
    }
}
 

@CalledByNative
public static void lockOrientation(@Nullable WindowAndroid window, byte webScreenOrientation) {
    // WindowAndroid may be null if the tab is being reparented.
    if (window == null) return;
    Activity activity = window.getActivity().get();

    // Locking orientation is only supported for web contents that have an associated activity.
    // Note that we can't just use the focused activity, as that would lead to bugs where
    // unlockOrientation unlocks a different activity to the one that was locked.
    if (activity == null) return;

    int orientation = getOrientationFromWebScreenOrientations(webScreenOrientation, window,
            activity);
    if (orientation == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
        return;
    }

    activity.setRequestedOrientation(orientation);
}
 

@Override
public void callActivityOnCreate(Activity activity, Bundle icicle) {
       VirtualCore.get().getComponentDelegate().beforeActivityCreate(activity);
	IBinder token = mirror.android.app.Activity.mToken.get(activity);
	ActivityClientRecord r = VActivityManager.get().getActivityRecord(token);
	if (r != null) {
           r.activity = activity;
       }
	ContextFixer.fixContext(activity);
	ActivityFixer.fixActivity(activity);
	ActivityInfo info = null;
	if (r != null) {
           info = r.info;
       }
	if (info != null) {
           if (info.theme != 0) {
               activity.setTheme(info.theme);
           }
           if (activity.getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
                   && info.screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
               activity.setRequestedOrientation(info.screenOrientation);
           }
       }
	super.callActivityOnCreate(activity, icicle);
	VirtualCore.get().getComponentDelegate().afterActivityCreate(activity);
}
 

/**
 * Called by the {@link android.app.Activity#onPostCreate(Bundle)} to update
 * the state of the container screen.
 */
public void syncScreenState() {
    int screenOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
    int navigationBarColor = -1;

    if (currentFragment instanceof FlowrFragment) {
        screenOrientation = ((FlowrFragment) currentFragment).getScreenOrientation();
        navigationBarColor = ((FlowrFragment) currentFragment).getNavigationBarColor();
    }

    if (screen != null) {
        screen.onCurrentFragmentChanged(getCurrentFragment());
        screen.setScreenOrientation(screenOrientation);
        screen.setNavigationBarColor(navigationBarColor);
    }

    syncToolbarState();
    syncDrawerState();
}
 

public static int getOrientation(Context context) {
    SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(context);
    int value = 0;
    try {
        value = Integer.valueOf(pref.getString(Settings.ORIENTATION, "0"));
    } catch (NumberFormatException e) {
    }
    if (value == 0) {
        return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
    } else if (value == 1) {
        return ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
    }
    return ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
}
 

public static String screenOrientationDesc(int curScreenOr) {
    String oriDesc = curScreenOr + "";
    switch (curScreenOr) {
        case ActivityInfo.SCREEN_ORIENTATION_BEHIND:
            oriDesc = "在后面BEHIND";
            break;
        case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
            oriDesc = "竖屏";
            break;
        case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
            oriDesc = "横屏";
            break;
        case ActivityInfo.SCREEN_ORIENTATION_USER:
            oriDesc = "跟随用户";
            break;
        case ActivityInfo.SCREEN_ORIENTATION_SENSOR:
            oriDesc = "跟随传感器";
            break;
        case ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED:
            oriDesc = "未指明的";
            break;
        case ActivityInfo.SCREEN_ORIENTATION_LOCKED:
            oriDesc = "locked";
            break;
    }
    return oriDesc;
}
 

protected void injectActivity(Activity activity) {
    final Intent intent = activity.getIntent();
    if (PluginUtil.isIntentFromPlugin(intent)) {
        Context base = activity.getBaseContext();
        try {
            LoadedPlugin plugin = this.mPluginManager.getLoadedPlugin(intent);
            Reflector.with(base).field("mResources").set(plugin.getResources());
            Reflector reflector = Reflector.with(activity);
            reflector.field("mBase").set(plugin.createPluginContext(activity.getBaseContext()));
            reflector.field("mApplication").set(plugin.getApplication());

            // set screenOrientation
            ActivityInfo activityInfo = plugin.getActivityInfo(PluginUtil.getComponent(intent));
            if (activityInfo.screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
                activity.setRequestedOrientation(activityInfo.screenOrientation);
            }

            // for native activity
            ComponentName component = PluginUtil.getComponent(intent);
            Intent wrapperIntent = new Intent(intent);
            wrapperIntent.setClassName(component.getPackageName(), component.getClassName());
            activity.setIntent(wrapperIntent);
            
        } catch (Exception e) {
            Log.w(TAG, e);
        }
    }
}
 

private int getCameraPictureOrientation() {
  if (getActivity().getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
    outputOrientation = getCameraPictureRotation(getActivity().getWindowManager()
                                                              .getDefaultDisplay()
                                                              .getOrientation());
  } else if (getCameraInfo().facing == CameraInfo.CAMERA_FACING_FRONT) {
    outputOrientation = (360 - displayOrientation) % 360;
  } else {
    outputOrientation = displayOrientation;
  }

  return outputOrientation;
}
 

@SuppressWarnings("WrongConstant")
@Override
public void setScreenOrientation(int orientation) {
    // if the orientation is unspecified we set it to activity default
    if (orientation == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
        setRequestedOrientation(getDefaultOrientation());
    } else {
        setRequestedOrientation(orientation);
    }
}
 

private static int getManifestOrientation(Activity activity){
    try {
        ActivityInfo app = activity.getPackageManager().getActivityInfo(activity.getComponentName(), PackageManager.GET_ACTIVITIES|PackageManager.GET_META_DATA);
        return app.screenOrientation;
    } catch (PackageManager.NameNotFoundException e) {
        return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
    }
}
 

/**
 * The requested screen orientation. Commonly used values are
    unspecified (-1), landscape (0), portrait (1), sensor (4), and user (2).  " +
    "See the Android developer documentation for ActivityInfo.Screen_Orientation for the " +
    "complete list of possible settings.
 *
 * ScreenOrientation property getter method.
 *
 * @return  screen orientation
 */
@SimpleProperty(category = PropertyCategory.APPEARANCE,
    description = "The requested screen orientation, specified as a text value.  " +
    "Commonly used values are " +
    "landscape, portrait, sensor, user and unspecified.  " +
    "See the Android developer documentation for ActivityInfo.Screen_Orientation for the " +
    "complete list of possible settings.")
public String ScreenOrientation() {
  switch (getRequestedOrientation()) {
    case ActivityInfo.SCREEN_ORIENTATION_BEHIND:
      return "behind";
    case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
      return "landscape";
    case ActivityInfo.SCREEN_ORIENTATION_NOSENSOR:
      return "nosensor";
    case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
      return "portrait";
    case ActivityInfo.SCREEN_ORIENTATION_SENSOR:
      return "sensor";
    case ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED:
      return "unspecified";
    case ActivityInfo.SCREEN_ORIENTATION_USER:
      return "user";
    case 10: // ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR
      return "fullSensor";
    case 8: // ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
      return "reverseLandscape";
    case 9: // ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
      return "reversePortrait";
    case 6: // ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
      return "sensorLandscape";
    case 7: // ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
      return "sensorPortrait";
  }

  return "unspecified";
}
 

public static String getOrientationString(int orientation) {
    switch (orientation) {
        case ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED:
            return "Unspecified";
        case ActivityInfo.SCREEN_ORIENTATION_BEHIND:
            return "Behind";
        case ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR:
            return "Full sensor";
        case ActivityInfo.SCREEN_ORIENTATION_FULL_USER:
            return "Full user";
        case ActivityInfo.SCREEN_ORIENTATION_LOCKED:
            return "Locked";
        case ActivityInfo.SCREEN_ORIENTATION_NOSENSOR:
            return "No sensor";
        case ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE:
            return "Landscape";
        case ActivityInfo.SCREEN_ORIENTATION_PORTRAIT:
            return "Portrait";
        case ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT:
            return "Reverse portrait";
        case ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE:
            return "Reverse landscape";
        case ActivityInfo.SCREEN_ORIENTATION_USER:
            return "User";
        case ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE:
            return "Sensor landscape";
        case ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT:
            return "Sensor portrait";
        case ActivityInfo.SCREEN_ORIENTATION_SENSOR:
            return "Sensor";
        case ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE:
            return "User landscape";
        case ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT:
            return "User portrait";
        default:
            return "null";
    }
}
 

private int getCameraPictureOrientation() {
  if (getActivity().getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
    outputOrientation = getCameraPictureRotation(getActivity().getWindowManager()
                                                              .getDefaultDisplay()
                                                              .getOrientation());
  } else if (getCameraInfo().facing == CameraInfo.CAMERA_FACING_FRONT) {
    outputOrientation = (360 - displayOrientation) % 360;
  } else {
    outputOrientation = displayOrientation;
  }

  return outputOrientation;
}
 

/**
 * 设置屏幕方向--注意targetSDK设置27以上不能设置windowIsTranslucent=true属性不然应用直接崩溃-强烈建议手机应用锁定竖屏
 * 错误为 Only fullscreen activities can request orientation
 * 默认自动 ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
 * 竖屏 ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
 * 横屏 ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
 * {@link ActivityInfo#screenOrientation ActivityInfo.screenOrientation}
 *
 * @param activity
 */
public void setActivityOrientation(Activity activity) {
    //全局控制屏幕横竖屏
    //先判断xml没有设置屏幕模式避免将开发者本身想设置的覆盖掉
    if (activity.getRequestedOrientation() == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
        try {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        } catch (Exception e) {
            e.printStackTrace();
            LoggerManager.e(TAG, "setRequestedOrientation:" + e.getMessage());
        }
    }
}
 

/**
 * 初始化
 * 包括设置theme，android2.3需要在super.oncreate之前调用settheme
 *
 * @param bundle Bundle
 */
public boolean initTargetActivity(Bundle bundle) {
    Intent curIntent = super.getIntent();
    if (curIntent == null) {
        finish();
        return false;
    }

    GPTComponentInfo info = GPTComponentInfo.parseFromIntent(curIntent);
    if (info == null) {
        finish();
        return false;
    }

    String targetClassName = info.className;
    String targetPackageName = info.packageName;

    mTargetPackageName = targetPackageName;
    mTargetClassName = targetClassName;

    if (!ProxyEnvironment.isEnterProxy(targetPackageName)
            || ProxyEnvironment.getInstance(targetPackageName).getRemapedActivityClass(targetClassName) != this
            .getClass()) {

        if (targetClassName == null) {
            targetClassName = "";
        }

        if (!TextUtils.isEmpty(targetPackageName)) {

            if (!info.reschedule) {
                Intent intent = new Intent(super.getIntent());
                intent.setComponent(new ComponentName(targetPackageName, targetClassName));
                ProxyEnvironment.enterProxy(super.getApplicationContext(), intent, true, true);
            }
        }
        finish();
        return false;
    }

    // 设置屏幕方向
    int orientation = ProxyEnvironment.getInstance(mTargetPackageName).getTargetActivityOrientation(
            mTargetClassName);
    if (orientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
        setRequestedOrientation(orientation);
    }

    // 设置主题
    setTheme(ProxyEnvironment.getInstance(targetPackageName).getTargetActivityThemeResource(targetClassName));

    return true;
}
 

/**
 * @inheritDoc
 */
@Override
public int getScreenOrientation() {
    return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
}
 

/**
 * 为插件中的Activity分配代理
 *
 * @param mLoadedApk 插件的实例
 * @param actInfo    插件Activity对应的ActivityInfo
 * @return 返回代理Activity的类名
 */
public static String findActivityProxy(PluginLoadedApk mLoadedApk, ActivityInfo actInfo) {
    boolean isTranslucent = false;
    boolean isHandleConfigChange = false;
    boolean isLandscape = false;
    boolean hasTaskAffinity = false;
    boolean supportPip = false;

    //通过主题判断是否是透明的
    Resources.Theme mTheme = mLoadedApk.getPluginTheme();
    isTranslucent = ActivityInfoUtils.isTranslucentTheme(mTheme, actInfo);
    if (!isTranslucent) {
        //兼容遗留逻辑
        if (actInfo.metaData != null) {
            String special_cfg = actInfo.metaData.getString(IntentConstant.META_KEY_ACTIVITY_SPECIAL);
            if (!TextUtils.isEmpty(special_cfg)) {
                if (special_cfg.contains(IntentConstant.PLUGIN_ACTIVITY_TRANSLUCENT)) {
                    PluginDebugLog.runtimeLog(TAG,
                            "findActivityProxy meta data contains translucent flag");
                    isTranslucent = true;
                }

                if (special_cfg.contains(IntentConstant.PLUGIN_ACTIVTIY_HANDLE_CONFIG_CHAGNE)) {
                    PluginDebugLog.runtimeLog(TAG,
                            "findActivityProxy meta data contains handleConfigChange flag");
                    isHandleConfigChange = true;
                }
            }
        }
    }

    if (supportPictureInPicture(actInfo)) {
        PluginDebugLog.runtimeLog(TAG, "findActivityProxy activity taskAffinity: "
                + actInfo.taskAffinity + " hasTaskAffinity = true" + ", supportPictureInPicture = true");
        supportPip = true;
    }

    if (actInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
        String pkgName = mLoadedApk.getPluginPackageName();
        if (TextUtils.equals(actInfo.taskAffinity, pkgName + IntentConstant.TASK_AFFINITY_CONTAINER1)) {
            PluginDebugLog.runtimeLog(TAG, "findActivityProxy activity taskAffinity: "
                    + actInfo.taskAffinity + " hasTaskAffinity = true");
            hasTaskAffinity = true;
        }
    }

    if (actInfo.screenOrientation != ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) {
        PluginDebugLog.runtimeLog(TAG, "findActivityProxy activity screenOrientation: "
                + actInfo.screenOrientation + " isHandleConfigChange = false");
        isHandleConfigChange = false;
    }

    if (actInfo.screenOrientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
        PluginDebugLog.runtimeLog(TAG, "findActivityProxy isLandscape = true");
        isLandscape = true;
    }

    return matchActivityProxyByFeature(supportPip, hasTaskAffinity, isTranslucent, isLandscape,
            isHandleConfigChange, mLoadedApk.getProcessName());
}
 

private static int getOrientationFromWebScreenOrientations(byte orientation,
        @Nullable WindowAndroid window, Context context) {
    switch (orientation) {
        case ScreenOrientationValues.DEFAULT:
            return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
        case ScreenOrientationValues.PORTRAIT_PRIMARY:
            return ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        case ScreenOrientationValues.PORTRAIT_SECONDARY:
            return ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
        case ScreenOrientationValues.LANDSCAPE_PRIMARY:
            return ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
        case ScreenOrientationValues.LANDSCAPE_SECONDARY:
            return ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
        case ScreenOrientationValues.PORTRAIT:
            return ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT;
        case ScreenOrientationValues.LANDSCAPE:
            return ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
        case ScreenOrientationValues.ANY:
            return ActivityInfo.SCREEN_ORIENTATION_FULL_SENSOR;
        case ScreenOrientationValues.NATURAL:
            // If the tab is being reparented, we don't have a display strongly associated with
            // it, so we get the default display.
            DisplayAndroid displayAndroid = (window != null) ? window.getDisplay()
                    : DisplayAndroid.getNonMultiDisplay(context);
            int rotation = displayAndroid.getRotation();
            if (rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) {
                if (displayAndroid.getDisplayHeight() >= displayAndroid.getDisplayWidth()) {
                    return ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
                }
                return ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            } else {
                if (displayAndroid.getDisplayHeight() < displayAndroid.getDisplayWidth()) {
                    return ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
                }
                return ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
            }
        default:
            Log.w(TAG, "Trying to lock to unsupported orientation!");
            return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
    }
}
 

@Override
public void onClick(DialogInterface dialog, int which) {
    if (mGalleryView == null) {
        return;
    }

    int screenRotation = mScreenRotation.getSelectedItemPosition();
    int layoutMode = GalleryView.sanitizeLayoutMode(mReadingDirection.getSelectedItemPosition());
    int scaleMode = GalleryView.sanitizeScaleMode(mScaleMode.getSelectedItemPosition());
    int startPosition = GalleryView.sanitizeStartPosition(mStartPosition.getSelectedItemPosition());
    boolean keepScreenOn = mKeepScreenOn.isChecked();
    boolean showClock = mShowClock.isChecked();
    boolean showProgress = mShowProgress.isChecked();
    boolean showBattery = mShowBattery.isChecked();
    boolean showPageInterval = mShowPageInterval.isChecked();
    boolean volumePage = mVolumePage.isChecked();
    boolean readingFullscreen = mReadingFullscreen.isChecked();
    boolean customScreenLightness = mCustomScreenLightness.isChecked();
    int screenLightness = mScreenLightness.getProgress();

    boolean oldReadingFullscreen = Settings.getReadingFullscreen();

    Settings.putScreenRotation(screenRotation);
    Settings.putReadingDirection(layoutMode);
    Settings.putPageScaling(scaleMode);
    Settings.putStartPosition(startPosition);
    Settings.putKeepScreenOn(keepScreenOn);
    Settings.putShowClock(showClock);
    Settings.putShowProgress(showProgress);
    Settings.putShowBattery(showBattery);
    Settings.putShowPageInterval(showPageInterval);
    Settings.putVolumePage(volumePage);
    Settings.putReadingFullscreen(readingFullscreen);
    Settings.putCustomScreenLightness(customScreenLightness);
    Settings.putScreenLightness(screenLightness);

    int orientation;
    switch (screenRotation) {
        default:
        case 0:
            orientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
            break;
        case 1:
            orientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT;
            break;
        case 2:
            orientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
            break;
    }
    setRequestedOrientation(orientation);
    mGalleryView.setLayoutMode(layoutMode);
    mGalleryView.setScaleMode(scaleMode);
    mGalleryView.setStartPosition(startPosition);
    if (keepScreenOn) {
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    } else {
        getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    }
    if (mClock != null) {
        mClock.setVisibility(showClock ? View.VISIBLE : View.GONE);
    }
    if (mProgress != null) {
        mProgress.setVisibility(showProgress ? View.VISIBLE : View.GONE);
    }
    if (mBattery != null) {
        mBattery.setVisibility(showBattery ? View.VISIBLE : View.GONE);
    }
    mGalleryView.setPagerInterval(showPageInterval ? getResources().getDimensionPixelOffset(R.dimen.gallery_pager_interval) : 0);
    mGalleryView.setScrollInterval(showPageInterval ? getResources().getDimensionPixelOffset(R.dimen.gallery_scroll_interval) : 0);
    setScreenLightness(customScreenLightness, screenLightness);

    // Update slider
    mLayoutMode = layoutMode;
    updateSlider();

    if (oldReadingFullscreen != readingFullscreen) {
        recreate();
    }
}