The {@link #FLAG_IMMERSIVE_STICKY} flag can be used to control how the system bars are + * displayed. + */ + public static final int LEVEL_IMMERSIVE = 3; + + /** + * When this flag is set, the + * {@link android.view.WindowManager.LayoutParams#FLAG_LAYOUT_IN_SCREEN} + * flag will be set on older devices, making the status bar "float" on top + * of the activity layout. This is most useful when there are no controls at + * the top of the activity layout. + *
+ * This flag isn't used on newer devices because the action + * bar, the most important structural element of an Android app, should + * be visible and not obscured by the system UI. + */ + public static final int FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES = 0x1; + + /** + * Used with {@link #LEVEL_IMMERSIVE}. When this flag is set, an inward swipe in the system + * bars areas will cause the system bars to temporarily appear in a semi-transparent state, + * but no flags are cleared, and your system UI visibility change listeners are not triggered. + * The bars automatically hide again after a short delay, or if the user interacts with the + * middle of the screen. + */ + public static final int FLAG_IMMERSIVE_STICKY = 0x2; + + private static final String LOG_TAG = SystemUiHelper.class.getSimpleName(); + + private final SystemUiHelperImpl mImpl; + + private final Handler mHandler; + private final Runnable mHideRunnable; + + /** + * Construct a new SystemUiHelper. + * + * @param activity The Activity who's system UI should be changed + * @param level The level of hiding. Should be either {@link #LEVEL_LOW_PROFILE}, + * {@link #LEVEL_HIDE_STATUS_BAR}, {@link #LEVEL_LEAN_BACK} or + * {@link #LEVEL_IMMERSIVE} + * @param flags Additional options. See {@link #FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES} and + * {@link #FLAG_IMMERSIVE_STICKY} + */ + public SystemUiHelper(Activity activity, int level, int flags) { + this(activity, level, flags, null); + } + + /** + * Construct a new SystemUiHelper. + * + * @param activity The Activity who's system UI should be changed + * @param level The level of hiding. Should be either {@link #LEVEL_LOW_PROFILE}, + * {@link #LEVEL_HIDE_STATUS_BAR}, {@link #LEVEL_LEAN_BACK} or + * {@link #LEVEL_IMMERSIVE} + * @param flags Additional options. See {@link #FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES} and + * {@link #FLAG_IMMERSIVE_STICKY} + * @param listener A listener which is called when the system visibility is changed + */ + public SystemUiHelper(Activity activity, int level, int flags, + OnVisibilityChangeListener listener) { + + mHandler = new Handler(Looper.getMainLooper()); + mHideRunnable = new HideRunnable(); + + // Create impl + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { + mImpl = new SystemUiHelperImplKK(activity, level, flags, listener); + } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { + mImpl = new SystemUiHelperImplJB(activity, level, flags, listener); + } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) { + mImpl = new SystemUiHelperImplICS(activity, level, flags, listener); + } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { + mImpl = new SystemUiHelperImplHC(activity, level, flags, listener); + } else { + mImpl = new SystemUiHelperImplBase(activity, level, flags, listener); + } + } + + /** + * @return true if the system UI is currently showing. What this means depends on the mode this + * {@link SystemUiHelper} was instantiated with. + */ + public boolean isShowing() { + return mImpl.isShowing(); + } + + /** + * Show the system UI. What this means depends on the mode this {@link SystemUiHelper} was + * instantiated with. + * + *
Any currently queued delayed hide requests will be removed. + */ + public void show() { + // Ensure that any currently queued hide calls are removed + removeQueuedRunnables(); + + mImpl.show(); + } + + /** + * Hide the system UI. What this means depends on the mode this {@link SystemUiHelper} was + * instantiated with. + * + *
Any currently queued delayed hide requests will be removed. + */ + public void hide() { + // Ensure that any currently queued hide calls are removed + removeQueuedRunnables(); + + mImpl.hide(); + } + + /** + * Request that the system UI is hidden after a delay. + * + *
Any currently queued delayed hide requests will be removed.
+ *
+ * @param delayMillis The delay (in milliseconds) until the Runnable
+ * will be executed.
+ */
+ public void delayHide(long delayMillis) {
+ // Ensure that any currently queued hide calls are removed
+ removeQueuedRunnables();
+
+ mHandler.postDelayed(mHideRunnable, delayMillis);
+ }
+
+ /**
+ * Toggle whether the system UI is displayed.
+ */
+ public void toggle() {
+ if (mImpl.isShowing()) {
+ mImpl.hide();
+ } else {
+ mImpl.show();
+ }
+ }
+
+ private void removeQueuedRunnables() {
+ // Ensure that any currently queued hide calls are removed
+ mHandler.removeCallbacks(mHideRunnable);
+ }
+
+ /**
+ * A callback interface used to listen for system UI visibility changes.
+ */
+ public interface OnVisibilityChangeListener {
+ /**
+ * Called when the system UI visibility has changed.
+ *
+ * @param visible True if the system UI is visible.
+ */
+ public void onVisibilityChange(boolean visible);
+ }
+
+ static abstract class SystemUiHelperImpl {
+
+ final Activity mActivity;
+ final int mLevel;
+ final int mFlags;
+ final OnVisibilityChangeListener mOnVisibilityChangeListener;
+
+ boolean mIsShowing = true;
+
+ SystemUiHelperImpl(Activity activity, int level, int flags,
+ OnVisibilityChangeListener onVisibilityChangeListener) {
+ mActivity = activity;
+ mLevel = level;
+ mFlags = flags;
+ mOnVisibilityChangeListener = onVisibilityChangeListener;
+ }
+
+ abstract void show();
+ abstract void hide();
+
+ boolean isShowing() {
+ return mIsShowing;
+ }
+
+ void setIsShowing(boolean isShowing) {
+ mIsShowing = isShowing;
+
+ if (mOnVisibilityChangeListener != null) {
+ mOnVisibilityChangeListener.onVisibilityChange(mIsShowing);
+ }
+ }
+ }
+
+ /**
+ * Base implementation. Used on API level 10 and below.
+ */
+ static class SystemUiHelperImplBase extends SystemUiHelperImpl {
+
+ SystemUiHelperImplBase(Activity activity, int level, int flags,
+ OnVisibilityChangeListener onVisibilityChangeListener) {
+ super(activity, level, flags, onVisibilityChangeListener);
+
+ if ((mFlags & SystemUiHelper.FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES) != 0) {
+ mActivity.getWindow().addFlags(
+ WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
+ | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
+ }
+ }
+
+ @Override
+ void show() {
+ if (mLevel > SystemUiHelper.LEVEL_LOW_PROFILE) {
+ mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+ setIsShowing(true);
+ }
+ }
+
+ @Override
+ void hide() {
+ if (mLevel > SystemUiHelper.LEVEL_LOW_PROFILE) {
+ mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+ setIsShowing(false);
+ }
+ }
+ }
+
+ private class HideRunnable implements Runnable {
+ @Override
+ public void run() {
+ hide();
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/hippo/util/SystemUiHelperImplHC.java b/app/src/main/java/com/hippo/util/SystemUiHelperImplHC.java
new file mode 100644
index 000000000..c7195457e
--- /dev/null
+++ b/app/src/main/java/com/hippo/util/SystemUiHelperImplHC.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2014 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.hippo.util;
+
+import android.annotation.TargetApi;
+import android.app.ActionBar;
+import android.app.Activity;
+import android.os.Build;
+import android.view.View;
+import android.view.WindowManager;
+
+@TargetApi(Build.VERSION_CODES.HONEYCOMB)
+class SystemUiHelperImplHC extends SystemUiHelper.SystemUiHelperImpl
+ implements View.OnSystemUiVisibilityChangeListener {
+
+ final View mDecorView;
+
+ SystemUiHelperImplHC(Activity activity, int level, int flags,
+ SystemUiHelper.OnVisibilityChangeListener onVisibilityChangeListener) {
+ super(activity, level, flags, onVisibilityChangeListener);
+
+ mDecorView = activity.getWindow().getDecorView();
+ mDecorView.setOnSystemUiVisibilityChangeListener(this);
+ }
+
+
+ @Override
+ void show() {
+ mDecorView.setSystemUiVisibility(createShowFlags());
+ }
+
+ @Override
+ void hide() {
+ mDecorView.setSystemUiVisibility(createHideFlags());
+ }
+
+ @Override
+ public final void onSystemUiVisibilityChange(int visibility) {
+ if ((visibility & createTestFlags()) != 0) {
+ onSystemUiHidden();
+ } else {
+ onSystemUiShown();
+ }
+ }
+
+ protected void onSystemUiShown() {
+ ActionBar ab = mActivity.getActionBar();
+ if (ab != null) {
+ ab.show();
+ }
+
+ mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+ setIsShowing(true);
+ }
+
+ protected void onSystemUiHidden() {
+ ActionBar ab = mActivity.getActionBar();
+ if (ab != null) {
+ ab.hide();
+ }
+
+ mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+ setIsShowing(false);
+ }
+
+ protected int createShowFlags() {
+ return View.STATUS_BAR_VISIBLE;
+ }
+
+ protected int createHideFlags() {
+ return View.STATUS_BAR_HIDDEN;
+ }
+
+ protected int createTestFlags() {
+ return View.STATUS_BAR_HIDDEN;
+ }
+}
diff --git a/app/src/main/java/com/hippo/util/SystemUiHelperImplICS.java b/app/src/main/java/com/hippo/util/SystemUiHelperImplICS.java
new file mode 100644
index 000000000..dcf2e249b
--- /dev/null
+++ b/app/src/main/java/com/hippo/util/SystemUiHelperImplICS.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2014 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.hippo.util;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.os.Build;
+import android.view.View;
+
+@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+class SystemUiHelperImplICS extends SystemUiHelperImplHC {
+
+ SystemUiHelperImplICS(Activity activity, int level, int flags,
+ SystemUiHelper.OnVisibilityChangeListener onVisibilityChangeListener) {
+ super(activity, level, flags, onVisibilityChangeListener);
+ }
+
+ @Override
+ protected int createShowFlags() {
+ return View.SYSTEM_UI_FLAG_VISIBLE;
+ }
+
+ @Override
+ protected int createTestFlags() {
+ if (mLevel >= SystemUiHelper.LEVEL_LEAN_BACK) {
+ // Intentionally override test flags.
+ return View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
+ }
+
+ return View.SYSTEM_UI_FLAG_LOW_PROFILE;
+ }
+
+ @Override
+ protected int createHideFlags() {
+ int flag = View.SYSTEM_UI_FLAG_LOW_PROFILE;
+
+ if (mLevel >= SystemUiHelper.LEVEL_LEAN_BACK) {
+ flag |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;
+ }
+
+ return flag;
+ }
+}
diff --git a/app/src/main/java/com/hippo/util/SystemUiHelperImplJB.java b/app/src/main/java/com/hippo/util/SystemUiHelperImplJB.java
new file mode 100644
index 000000000..26fb0c1f0
--- /dev/null
+++ b/app/src/main/java/com/hippo/util/SystemUiHelperImplJB.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2014 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.hippo.util;
+
+import android.annotation.TargetApi;
+import android.app.ActionBar;
+import android.app.Activity;
+import android.os.Build;
+import android.view.View;
+
+@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+class SystemUiHelperImplJB extends SystemUiHelperImplICS {
+
+ SystemUiHelperImplJB(Activity activity, int level, int flags,
+ SystemUiHelper.OnVisibilityChangeListener onVisibilityChangeListener) {
+ super(activity, level, flags, onVisibilityChangeListener);
+ }
+
+ @Override
+ protected int createShowFlags() {
+ int flag = super.createShowFlags();
+
+ if (mLevel >= SystemUiHelper.LEVEL_HIDE_STATUS_BAR) {
+ flag |= View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
+
+ if (mLevel >= SystemUiHelper.LEVEL_LEAN_BACK) {
+ flag |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
+ }
+ }
+
+ return flag;
+ }
+
+ @Override
+ protected int createHideFlags() {
+ int flag = super.createHideFlags();
+
+ if (mLevel >= SystemUiHelper.LEVEL_HIDE_STATUS_BAR) {
+ flag |= View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+ | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+ | View.SYSTEM_UI_FLAG_FULLSCREEN;
+
+ if (mLevel >= SystemUiHelper.LEVEL_LEAN_BACK) {
+ flag |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION;
+ }
+ }
+
+ return flag;
+ }
+
+ @Override
+ protected void onSystemUiShown() {
+ if (mLevel == SystemUiHelper.LEVEL_LOW_PROFILE) {
+ // Manually show the action bar when in low profile mode.
+ ActionBar ab = mActivity.getActionBar();
+ if (ab != null) {
+ ab.show();
+ }
+ }
+
+ setIsShowing(true);
+ }
+
+ @Override
+ protected void onSystemUiHidden() {
+ if (mLevel == SystemUiHelper.LEVEL_LOW_PROFILE) {
+ // Manually hide the action bar when in low profile mode.
+ ActionBar ab = mActivity.getActionBar();
+ if (ab != null) {
+ ab.hide();
+ }
+ }
+
+ setIsShowing(false);
+ }
+}
diff --git a/app/src/main/java/com/hippo/util/SystemUiHelperImplKK.java b/app/src/main/java/com/hippo/util/SystemUiHelperImplKK.java
new file mode 100644
index 000000000..8bc5be6c3
--- /dev/null
+++ b/app/src/main/java/com/hippo/util/SystemUiHelperImplKK.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2014 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.hippo.util;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.os.Build;
+import android.view.View;
+
+@TargetApi(Build.VERSION_CODES.KITKAT)
+class SystemUiHelperImplKK extends SystemUiHelperImplJB {
+
+ SystemUiHelperImplKK(Activity activity, int level, int flags,
+ SystemUiHelper.OnVisibilityChangeListener onVisibilityChangeListener) {
+ super(activity, level, flags, onVisibilityChangeListener);
+ }
+
+ @Override
+ protected int createHideFlags() {
+ int flag = super.createHideFlags();
+
+ if (mLevel == SystemUiHelper.LEVEL_IMMERSIVE) {
+ // If the client requested immersive mode, and we're on Android 4.4
+ // or later, add relevant flags. Applying HIDE_NAVIGATION without
+ // IMMERSIVE prevents the activity from accepting all touch events,
+ // so we only do this on Android 4.4 and later (where IMMERSIVE is
+ // present).
+ flag |= ((mFlags & SystemUiHelper.FLAG_IMMERSIVE_STICKY) != 0)
+ ? View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+ : View.SYSTEM_UI_FLAG_IMMERSIVE;
+ }
+
+ return flag;
+ }
+
+}
diff --git a/app/src/main/java/com/hippo/widget/BatteryView.java b/app/src/main/java/com/hippo/widget/BatteryView.java
new file mode 100644
index 000000000..c8a4b7fcc
--- /dev/null
+++ b/app/src/main/java/com/hippo/widget/BatteryView.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2014 Hippo Seven
+ *
+ * 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.hippo.widget;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.os.BatteryManager;
+import android.util.AttributeSet;
+import android.widget.TextView;
+
+import com.hippo.drawable.BatteryDrawable;
+import com.hippo.ehviewer.R;
+
+public class BatteryView extends TextView {
+
+ private int mColor;
+ private int mWarningColor;
+ private int mCurrentColor;
+
+ private int mLevel = 0;
+ private boolean mCharging = false;
+
+ private BatteryDrawable mDrawable;
+
+ private boolean mAttached = false;
+ private boolean mIsChargerWorking = false;
+
+ private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
+
+ @Override
+ @SuppressLint("SetTextI18n")
+ public void onReceive(Context context, Intent intent) {
+
+ int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0)
+ * 100 / intent.getIntExtra(BatteryManager.EXTRA_SCALE, 0);
+ boolean charging = (intent.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
+ == BatteryManager.BATTERY_STATUS_CHARGING);
+
+ if (mLevel != level || mCharging != charging) {
+ mLevel = level;
+ mCharging = charging;
+ if (mCharging && mLevel != 100) {
+ startCharger();
+ } else {
+ stopCharger();
+ mDrawable.setElect(mLevel);
+ }
+
+ if (level <= BatteryDrawable.WARN_LIMIT && !charging) {
+ setTextColor(mWarningColor);
+ } else {
+ setTextColor(mColor);
+ }
+ setText(mLevel + "%");
+ }
+ }
+ };
+
+ private final Runnable mCharger = new Runnable() {
+
+ private int level = 0;
+
+ @Override
+ public void run() {
+ level += 2;
+ if (level > 100) {
+ level = 0;
+ }
+ mDrawable.setElect(level, false);
+ getHandler().postDelayed(mCharger, 200);
+ }
+ };
+
+ public BatteryView(Context context) {
+ super(context);
+ init();
+ }
+
+ public BatteryView(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public BatteryView(Context context, AttributeSet attrs, int defStyleAttr) {
+ super(context, attrs, defStyleAttr);
+
+ init();
+
+ TypedArray typedArray = context.obtainStyledAttributes(
+ attrs, R.styleable.BatteryView, defStyleAttr, 0);
+ mColor = typedArray.getColor(R.styleable.BatteryView_color, Color.WHITE);
+ mWarningColor = typedArray.getColor(R.styleable.BatteryView_warningColor, Color.RED);
+ typedArray.recycle();
+
+ mDrawable.setColor(mColor);
+ mDrawable.setWarningColor(mWarningColor);
+ }
+
+ private void init() {
+ mDrawable = new BatteryDrawable();
+ int height = (int) getTextSize();
+ mDrawable.setBounds(0, 0, (int) (height / 0.618f), height);
+ setCompoundDrawables(mDrawable, null, null, null);
+ }
+
+ @Override
+ public void setTextColor(int color) {
+ if (mCurrentColor == color) {
+ return;
+ }
+ mCurrentColor = color;
+ super.setTextColor(color);
+ }
+
+ private void startCharger() {
+ if (!mIsChargerWorking) {
+ getHandler().post(mCharger);
+ mIsChargerWorking = true;
+ }
+ }
+
+ private void stopCharger() {
+ if (mIsChargerWorking) {
+ getHandler().removeCallbacks(mCharger);
+ mIsChargerWorking = false;
+ }
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+
+ if (!mAttached) {
+ mAttached = true;
+
+ registerReceiver();
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+
+ if (mAttached) {
+ unregisterReceiver();
+ stopCharger();
+ mAttached = false;
+ }
+ }
+
+ private void registerReceiver() {
+ final IntentFilter filter = new IntentFilter();
+ filter.addAction(Intent.ACTION_BATTERY_CHANGED);
+ getContext().registerReceiver(mIntentReceiver, filter, null, getHandler());
+ }
+
+ private void unregisterReceiver() {
+ getContext().unregisterReceiver(mIntentReceiver);
+ }
+}
diff --git a/app/src/main/java/com/hippo/widget/DateUtils.java b/app/src/main/java/com/hippo/widget/DateUtils.java
new file mode 100644
index 000000000..967214fe6
--- /dev/null
+++ b/app/src/main/java/com/hippo/widget/DateUtils.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2014 Hippo Seven
+ *
+ * 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.hippo.widget;
+
+final class DateUtils {
+
+ public static final char QUOTE = '\'';
+ public static final char SECONDS = 's';
+
+ public static boolean hasSeconds(CharSequence inFormat) {
+ return hasDesignator(inFormat, SECONDS);
+ }
+
+ public static boolean hasDesignator(CharSequence inFormat, char designator) {
+ if (inFormat == null) return false;
+
+ final int length = inFormat.length();
+
+ int c;
+ int count;
+
+ for (int i = 0; i < length; i += count) {
+ count = 1;
+ c = inFormat.charAt(i);
+
+ if (c == QUOTE) {
+ count = skipQuotedText(inFormat, i, length);
+ } else if (c == designator) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private static int skipQuotedText(CharSequence s, int i, int len) {
+ if (i + 1 < len && s.charAt(i + 1) == QUOTE) {
+ return 2;
+ }
+
+ int count = 1;
+ // skip leading quote
+ i++;
+
+ while (i < len) {
+ char c = s.charAt(i);
+
+ if (c == QUOTE) {
+ count++;
+ // QUOTEQUOTE -> QUOTE
+ if (i + 1 < len && s.charAt(i + 1) == QUOTE) {
+ i++;
+ } else {
+ break;
+ }
+ } else {
+ i++;
+ count++;
+ }
+ }
+
+ return count;
+ }
+}
diff --git a/app/src/main/java/com/hippo/widget/TextClock.java b/app/src/main/java/com/hippo/widget/TextClock.java
new file mode 100644
index 000000000..2cf52369c
--- /dev/null
+++ b/app/src/main/java/com/hippo/widget/TextClock.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2014 Hippo Seven
+ *
+ * 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.hippo.widget;
+
+import android.content.BroadcastReceiver;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.database.ContentObserver;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.os.SystemClock;
+import android.provider.Settings;
+import android.text.format.DateFormat;
+import android.util.AttributeSet;
+import android.view.ViewDebug.ExportedProperty;
+import android.widget.TextView;
+
+import java.util.Calendar;
+import java.util.TimeZone;
+
+public class TextClock extends TextView {
+
+ public static final CharSequence DEFAULT_FORMAT_12_HOUR = "hh:mm a";
+ public static final CharSequence DEFAULT_FORMAT_24_HOUR;
+
+ static {
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2)
+ DEFAULT_FORMAT_24_HOUR = "kk:mm";
+ else
+ DEFAULT_FORMAT_24_HOUR = "HH:mm";
+ }
+
+ private CharSequence mFormat12;
+ private CharSequence mFormat24;
+
+ @ExportedProperty
+ private CharSequence mFormat;
+ @ExportedProperty
+ private boolean mHasSeconds;
+
+ private boolean mAttached;
+
+ private Calendar mTime;
+ private String mTimeZone;
+
+ private final ContentObserver mFormatChangeObserver = new ContentObserver(new Handler()) {
+ @Override
+ public void onChange(boolean selfChange) {
+ chooseFormat();
+ onTimeChanged();
+ }
+
+ @Override
+ public void onChange(boolean selfChange, Uri uri) {
+ chooseFormat();
+ onTimeChanged();
+ }
+ };
+
+ private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ if (mTimeZone == null && Intent.ACTION_TIMEZONE_CHANGED.equals(intent.getAction())) {
+ final String timeZone = intent.getStringExtra("time-zone");
+ createTime(timeZone);
+ }
+ onTimeChanged();
+ }
+ };
+
+ private final Runnable mTicker = new Runnable() {
+ @Override
+ public void run() {
+ onTimeChanged();
+
+ long now = SystemClock.uptimeMillis();
+ long next = now + (1000 - now % 1000);
+
+ getHandler().postAtTime(mTicker, next);
+ }
+ };
+
+ public TextClock(Context context) {
+ this(context, null);
+ }
+
+ public TextClock(Context context, AttributeSet attrs) {
+ this(context, attrs, 0);
+ }
+
+ public TextClock(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+
+ mFormat12 = DEFAULT_FORMAT_12_HOUR;
+ mFormat24 = DEFAULT_FORMAT_24_HOUR;
+ mTimeZone = TimeZone.getDefault().getID();
+
+ init();
+ }
+
+ private void init() {
+ createTime(mTimeZone);
+ // Wait until onAttachedToWindow() to handle the ticker
+ chooseFormat(false);
+ }
+
+ private void createTime(String timeZone) {
+ if (timeZone != null) {
+ mTime = Calendar.getInstance(TimeZone.getTimeZone(timeZone));
+ } else {
+ mTime = Calendar.getInstance();
+ }
+ }
+
+ public CharSequence getFormat12Hour() {
+ return mFormat12;
+ }
+
+ public void setFormat12Hour(CharSequence format) {
+ mFormat12 = format;
+
+ chooseFormat();
+ onTimeChanged();
+ }
+
+ public CharSequence getFormat24Hour() {
+ return mFormat24;
+ }
+
+ public void setFormat24Hour(CharSequence format) {
+ mFormat24 = format;
+
+ chooseFormat();
+ onTimeChanged();
+ }
+
+ public boolean is24HourModeEnabled() {
+ return DateFormat.is24HourFormat(getContext());
+ }
+
+ public String getTimeZone() {
+ return mTimeZone;
+ }
+
+ public void setTimeZone(String timeZone) {
+ mTimeZone = timeZone;
+
+ createTime(timeZone);
+ onTimeChanged();
+ }
+
+ /**
+ * Selects either one of {@link #getFormat12Hour()} or {@link #getFormat24Hour()}
+ * depending on whether the user has selected 24-hour format.
+ *
+ * Calling this method does not schedule or unschedule the time ticker.
+ */
+ private void chooseFormat() {
+ chooseFormat(true);
+ }
+
+ public CharSequence getFormat() {
+ return mFormat;
+ }
+
+ /**
+ * Selects either one of {@link #getFormat12Hour()} or {@link #getFormat24Hour()}
+ * depending on whether the user has selected 24-hour format.
+ *
+ * @param handleTicker true if calling this method should schedule/unschedule the
+ * time ticker, false otherwise
+ */
+ private void chooseFormat(boolean handleTicker) {
+ final boolean format24Requested = is24HourModeEnabled();
+
+ if (format24Requested) {
+ mFormat = mFormat24;
+ } else {
+ mFormat = mFormat12;
+ }
+
+ boolean hadSeconds = mHasSeconds;
+ mHasSeconds = DateUtils.hasSeconds(mFormat);
+
+ if (handleTicker && mAttached && hadSeconds != mHasSeconds) {
+ if (hadSeconds) getHandler().removeCallbacks(mTicker);
+ else mTicker.run();
+ }
+ }
+
+ @Override
+ protected void onAttachedToWindow() {
+ super.onAttachedToWindow();
+
+ if (!mAttached) {
+ mAttached = true;
+
+ registerReceiver();
+ registerObserver();
+
+ createTime(mTimeZone);
+
+ if (mHasSeconds) {
+ mTicker.run();
+ } else {
+ onTimeChanged();
+ }
+ }
+ }
+
+ @Override
+ protected void onDetachedFromWindow() {
+ super.onDetachedFromWindow();
+
+ if (mAttached) {
+ unregisterReceiver();
+ unregisterObserver();
+
+ getHandler().removeCallbacks(mTicker);
+
+ mAttached = false;
+ }
+ }
+
+ private void registerReceiver() {
+ final IntentFilter filter = new IntentFilter();
+
+ filter.addAction(Intent.ACTION_TIME_TICK);
+ filter.addAction(Intent.ACTION_TIME_CHANGED);
+ filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
+
+ getContext().registerReceiver(mIntentReceiver, filter, null, getHandler());
+ }
+
+ private void registerObserver() {
+ final ContentResolver resolver = getContext().getContentResolver();
+ resolver.registerContentObserver(Settings.System.CONTENT_URI, true, mFormatChangeObserver);
+ }
+
+ private void unregisterReceiver() {
+ getContext().unregisterReceiver(mIntentReceiver);
+ }
+
+ private void unregisterObserver() {
+ final ContentResolver resolver = getContext().getContentResolver();
+ resolver.unregisterContentObserver(mFormatChangeObserver);
+ }
+
+ private void onTimeChanged() {
+ mTime.setTimeInMillis(System.currentTimeMillis());
+ setText(DateFormat.format(mFormat, mTime));
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/res/drawable-hdpi/ic_settings_eh.png b/app/src/main/res/drawable-hdpi/ic_settings_eh.png
index cc2a52bd2..3c9552b84 100644
Binary files a/app/src/main/res/drawable-hdpi/ic_settings_eh.png and b/app/src/main/res/drawable-hdpi/ic_settings_eh.png differ
diff --git a/app/src/main/res/drawable-hdpi/ic_settings_read.png b/app/src/main/res/drawable-hdpi/ic_settings_read.png
new file mode 100644
index 000000000..14a7b21ef
Binary files /dev/null and b/app/src/main/res/drawable-hdpi/ic_settings_read.png differ
diff --git a/app/src/main/res/drawable-mdpi/ic_settings_eh.png b/app/src/main/res/drawable-mdpi/ic_settings_eh.png
index d25b80e2d..06e4c57b5 100644
Binary files a/app/src/main/res/drawable-mdpi/ic_settings_eh.png and b/app/src/main/res/drawable-mdpi/ic_settings_eh.png differ
diff --git a/app/src/main/res/drawable-mdpi/ic_settings_read.png b/app/src/main/res/drawable-mdpi/ic_settings_read.png
new file mode 100644
index 000000000..79a20133f
Binary files /dev/null and b/app/src/main/res/drawable-mdpi/ic_settings_read.png differ
diff --git a/app/src/main/res/drawable-xhdpi/ic_settings_eh.png b/app/src/main/res/drawable-xhdpi/ic_settings_eh.png
index cb9c99302..9f97ded8b 100644
Binary files a/app/src/main/res/drawable-xhdpi/ic_settings_eh.png and b/app/src/main/res/drawable-xhdpi/ic_settings_eh.png differ
diff --git a/app/src/main/res/drawable-xhdpi/ic_settings_read.png b/app/src/main/res/drawable-xhdpi/ic_settings_read.png
new file mode 100644
index 000000000..07dcbb2d9
Binary files /dev/null and b/app/src/main/res/drawable-xhdpi/ic_settings_read.png differ
diff --git a/app/src/main/res/drawable-xxhdpi/ic_settings_eh.png b/app/src/main/res/drawable-xxhdpi/ic_settings_eh.png
index 461f819d5..d567e3d8e 100644
Binary files a/app/src/main/res/drawable-xxhdpi/ic_settings_eh.png and b/app/src/main/res/drawable-xxhdpi/ic_settings_eh.png differ
diff --git a/app/src/main/res/drawable-xxhdpi/ic_settings_read.png b/app/src/main/res/drawable-xxhdpi/ic_settings_read.png
new file mode 100644
index 000000000..2072b7ad6
Binary files /dev/null and b/app/src/main/res/drawable-xxhdpi/ic_settings_read.png differ
diff --git a/app/src/main/res/layout/activity_gallery.xml b/app/src/main/res/layout/activity_gallery.xml
index 9b10d9580..785b83ef1 100644
--- a/app/src/main/res/layout/activity_gallery.xml
+++ b/app/src/main/res/layout/activity_gallery.xml
@@ -15,8 +15,70 @@
~ limitations under the License.
-->
-