| @@ -0,0 +1,160 @@ | ||
| package zpln.hackgeny; | ||
|
|
||
| import zpln.hackgeny.util.SystemUiHider; | ||
|
|
||
| import android.annotation.TargetApi; | ||
| import android.app.Activity; | ||
| import android.os.Build; | ||
| import android.os.Bundle; | ||
| import android.os.Handler; | ||
| import android.view.MotionEvent; | ||
| import android.view.View; | ||
|
|
||
|
|
||
| /** | ||
| * An example full-screen activity that shows and hides the system UI (i.e. | ||
| * status bar and navigation/system bar) with user interaction. | ||
| * | ||
| * @see SystemUiHider | ||
| */ | ||
| public class FullscreenActivity extends Activity { | ||
| /** | ||
| * Whether or not the system UI should be auto-hidden after | ||
| * {@link #AUTO_HIDE_DELAY_MILLIS} milliseconds. | ||
| */ | ||
| private static final boolean AUTO_HIDE = true; | ||
|
|
||
| /** | ||
| * If {@link #AUTO_HIDE} is set, the number of milliseconds to wait after | ||
| * user interaction before hiding the system UI. | ||
| */ | ||
| private static final int AUTO_HIDE_DELAY_MILLIS = 3000; | ||
|
|
||
| /** | ||
| * If set, will toggle the system UI visibility upon interaction. Otherwise, | ||
| * will show the system UI visibility upon interaction. | ||
| */ | ||
| private static final boolean TOGGLE_ON_CLICK = true; | ||
|
|
||
| /** | ||
| * The flags to pass to {@link SystemUiHider#getInstance}. | ||
| */ | ||
| private static final int HIDER_FLAGS = SystemUiHider.FLAG_HIDE_NAVIGATION; | ||
|
|
||
| /** | ||
| * The instance of the {@link SystemUiHider} for this activity. | ||
| */ | ||
| private SystemUiHider mSystemUiHider; | ||
|
|
||
| @Override | ||
| protected void onCreate(Bundle savedInstanceState) { | ||
| super.onCreate(savedInstanceState); | ||
|
|
||
| setContentView(R.layout.activity_fullscreen); | ||
|
|
||
| final View controlsView = findViewById(R.id.fullscreen_content_controls); | ||
| final View contentView = findViewById(R.id.fullscreen_content); | ||
|
|
||
| // Set up an instance of SystemUiHider to control the system UI for | ||
| // this activity. | ||
| mSystemUiHider = SystemUiHider.getInstance(this, contentView, HIDER_FLAGS); | ||
| mSystemUiHider.setup(); | ||
| mSystemUiHider | ||
| .setOnVisibilityChangeListener(new SystemUiHider.OnVisibilityChangeListener() { | ||
| // Cached values. | ||
| int mControlsHeight; | ||
| int mShortAnimTime; | ||
|
|
||
| @Override | ||
| @TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2) | ||
| public void onVisibilityChange(boolean visible) { | ||
| if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) { | ||
| // If the ViewPropertyAnimator API is available | ||
| // (Honeycomb MR2 and later), use it to animate the | ||
| // in-layout UI controls at the bottom of the | ||
| // screen. | ||
| if (mControlsHeight == 0) { | ||
| mControlsHeight = controlsView.getHeight(); | ||
| } | ||
| if (mShortAnimTime == 0) { | ||
| mShortAnimTime = getResources().getInteger( | ||
| android.R.integer.config_shortAnimTime); | ||
| } | ||
| controlsView.animate() | ||
| .translationY(visible ? 0 : mControlsHeight) | ||
| .setDuration(mShortAnimTime); | ||
| } else { | ||
| // If the ViewPropertyAnimator APIs aren't | ||
| // available, simply show or hide the in-layout UI | ||
| // controls. | ||
| controlsView.setVisibility(visible ? View.VISIBLE : View.GONE); | ||
| } | ||
|
|
||
| if (visible && AUTO_HIDE) { | ||
| // Schedule a hide(). | ||
| delayedHide(AUTO_HIDE_DELAY_MILLIS); | ||
| } | ||
| } | ||
| }); | ||
|
|
||
| // Set up the user interaction to manually show or hide the system UI. | ||
| contentView.setOnClickListener(new View.OnClickListener() { | ||
| @Override | ||
| public void onClick(View view) { | ||
| if (TOGGLE_ON_CLICK) { | ||
| mSystemUiHider.toggle(); | ||
| } else { | ||
| mSystemUiHider.show(); | ||
| } | ||
| } | ||
| }); | ||
|
|
||
| // Upon interacting with UI controls, delay any scheduled hide() | ||
| // operations to prevent the jarring behavior of controls going away | ||
| // while interacting with the UI. | ||
| findViewById(R.id.dummy_button).setOnTouchListener(mDelayHideTouchListener); | ||
| } | ||
|
|
||
| @Override | ||
| protected void onPostCreate(Bundle savedInstanceState) { | ||
| super.onPostCreate(savedInstanceState); | ||
|
|
||
| // Trigger the initial hide() shortly after the activity has been | ||
| // created, to briefly hint to the user that UI controls | ||
| // are available. | ||
| delayedHide(100); | ||
| } | ||
|
|
||
|
|
||
| /** | ||
| * Touch listener to use for in-layout UI controls to delay hiding the | ||
| * system UI. This is to prevent the jarring behavior of controls going away | ||
| * while interacting with activity UI. | ||
| */ | ||
| View.OnTouchListener mDelayHideTouchListener = new View.OnTouchListener() { | ||
| @Override | ||
| public boolean onTouch(View view, MotionEvent motionEvent) { | ||
| if (AUTO_HIDE) { | ||
| delayedHide(AUTO_HIDE_DELAY_MILLIS); | ||
| } | ||
| return false; | ||
| } | ||
| }; | ||
|
|
||
| Handler mHideHandler = new Handler(); | ||
| Runnable mHideRunnable = new Runnable() { | ||
| @Override | ||
| public void run() { | ||
| mSystemUiHider.hide(); | ||
| } | ||
| }; | ||
|
|
||
| /** | ||
| * Schedules a call to hide() in [delay] milliseconds, canceling any | ||
| * previously scheduled calls. | ||
| */ | ||
| private void delayedHide(int delayMillis) { | ||
| mHideHandler.removeCallbacks(mHideRunnable); | ||
| mHideHandler.postDelayed(mHideRunnable, delayMillis); | ||
| } | ||
| } |
| @@ -0,0 +1,172 @@ | ||
| package zpln.hackgeny.util; | ||
|
|
||
| import android.app.Activity; | ||
| import android.os.Build; | ||
| import android.view.View; | ||
|
|
||
| /** | ||
| * A utility class that helps with showing and hiding system UI such as the | ||
| * status bar and navigation/system bar. This class uses backward-compatibility | ||
| * techniques described in <a href= | ||
| * "http://developer.android.com/training/backward-compatible-ui/index.html"> | ||
| * Creating Backward-Compatible UIs</a> to ensure that devices running any | ||
| * version of ndroid OS are supported. More specifically, there are separate | ||
| * implementations of this abstract class: for newer devices, | ||
| * {@link #getInstance} will return a {@link SystemUiHiderHoneycomb} instance, | ||
| * while on older devices {@link #getInstance} will return a | ||
| * {@link SystemUiHiderBase} instance. | ||
| * <p/> | ||
| * For more on system bars, see <a href= | ||
| * "http://developer.android.com/design/get-started/ui-overview.html#system-bars" | ||
| * > System Bars</a>. | ||
| * | ||
| * @see android.view.View#setSystemUiVisibility(int) | ||
| * @see android.view.WindowManager.LayoutParams#FLAG_FULLSCREEN | ||
| */ | ||
| public abstract class SystemUiHider { | ||
| /** | ||
| * 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. | ||
| * <p/> | ||
| * This flag isn't used on newer devices because the <a | ||
| * href="http://developer.android.com/design/patterns/actionbar.html">action | ||
| * bar</a>, 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; | ||
|
|
||
| /** | ||
| * When this flag is set, {@link #show()} and {@link #hide()} will toggle | ||
| * the visibility of the status bar. If there is a navigation bar, show and | ||
| * hide will toggle low profile mode. | ||
| */ | ||
| public static final int FLAG_FULLSCREEN = 0x2; | ||
|
|
||
| /** | ||
| * When this flag is set, {@link #show()} and {@link #hide()} will toggle | ||
| * the visibility of the navigation bar, if it's present on the device and | ||
| * the device allows hiding it. In cases where the navigation bar is present | ||
| * but cannot be hidden, show and hide will toggle low profile mode. | ||
| */ | ||
| public static final int FLAG_HIDE_NAVIGATION = FLAG_FULLSCREEN | 0x4; | ||
|
|
||
| /** | ||
| * The activity associated with this UI hider object. | ||
| */ | ||
| protected Activity mActivity; | ||
|
|
||
| /** | ||
| * The view on which {@link View#setSystemUiVisibility(int)} will be called. | ||
| */ | ||
| protected View mAnchorView; | ||
|
|
||
| /** | ||
| * The current UI hider flags. | ||
| * | ||
| * @see #FLAG_FULLSCREEN | ||
| * @see #FLAG_HIDE_NAVIGATION | ||
| * @see #FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES | ||
| */ | ||
| protected int mFlags; | ||
|
|
||
| /** | ||
| * The current visibility callback. | ||
| */ | ||
| protected OnVisibilityChangeListener mOnVisibilityChangeListener = sDummyListener; | ||
|
|
||
| /** | ||
| * Creates and returns an instance of {@link SystemUiHider} that is | ||
| * appropriate for this device. The object will be either a | ||
| * {@link SystemUiHiderBase} or {@link SystemUiHiderHoneycomb} depending on | ||
| * the device. | ||
| * | ||
| * @param activity The activity whose window's system UI should be | ||
| * controlled by this class. | ||
| * @param anchorView The view on which | ||
| * {@link View#setSystemUiVisibility(int)} will be called. | ||
| * @param flags Either 0 or any combination of {@link #FLAG_FULLSCREEN}, | ||
| * {@link #FLAG_HIDE_NAVIGATION}, and | ||
| * {@link #FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES}. | ||
| */ | ||
| public static SystemUiHider getInstance(Activity activity, View anchorView, int flags) { | ||
| if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { | ||
| return new SystemUiHiderHoneycomb(activity, anchorView, flags); | ||
| } else { | ||
| return new SystemUiHiderBase(activity, anchorView, flags); | ||
| } | ||
| } | ||
|
|
||
| protected SystemUiHider(Activity activity, View anchorView, int flags) { | ||
| mActivity = activity; | ||
| mAnchorView = anchorView; | ||
| mFlags = flags; | ||
| } | ||
|
|
||
| /** | ||
| * Sets up the system UI hider. Should be called from | ||
| * {@link Activity#onCreate}. | ||
| */ | ||
| public abstract void setup(); | ||
|
|
||
| /** | ||
| * Returns whether or not the system UI is visible. | ||
| */ | ||
| public abstract boolean isVisible(); | ||
|
|
||
| /** | ||
| * Hide the system UI. | ||
| */ | ||
| public abstract void hide(); | ||
|
|
||
| /** | ||
| * Show the system UI. | ||
| */ | ||
| public abstract void show(); | ||
|
|
||
| /** | ||
| * Toggle the visibility of the system UI. | ||
| */ | ||
| public void toggle() { | ||
| if (isVisible()) { | ||
| hide(); | ||
| } else { | ||
| show(); | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * Registers a callback, to be triggered when the system UI visibility | ||
| * changes. | ||
| */ | ||
| public void setOnVisibilityChangeListener(OnVisibilityChangeListener listener) { | ||
| if (listener == null) { | ||
| listener = sDummyListener; | ||
| } | ||
|
|
||
| mOnVisibilityChangeListener = listener; | ||
| } | ||
|
|
||
| /** | ||
| * A dummy no-op callback for use when there is no other listener set. | ||
| */ | ||
| private static OnVisibilityChangeListener sDummyListener = new OnVisibilityChangeListener() { | ||
| @Override | ||
| public void onVisibilityChange(boolean visible) { | ||
| } | ||
| }; | ||
|
|
||
| /** | ||
| * 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); | ||
| } | ||
| } |
| @@ -0,0 +1,63 @@ | ||
| package zpln.hackgeny.util; | ||
|
|
||
| import android.app.Activity; | ||
| import android.view.View; | ||
| import android.view.WindowManager; | ||
|
|
||
| /** | ||
| * A base implementation of {@link SystemUiHider}. Uses APIs available in all | ||
| * API levels to show and hide the status bar. | ||
| */ | ||
| public class SystemUiHiderBase extends SystemUiHider { | ||
| /** | ||
| * Whether or not the system UI is currently visible. This is a cached value | ||
| * from calls to {@link #hide()} and {@link #show()}. | ||
| */ | ||
| private boolean mVisible = true; | ||
|
|
||
| /** | ||
| * Constructor not intended to be called by clients. Use | ||
| * {@link SystemUiHider#getInstance} to obtain an instance. | ||
| */ | ||
| protected SystemUiHiderBase(Activity activity, View anchorView, int flags) { | ||
| super(activity, anchorView, flags); | ||
| } | ||
|
|
||
| @Override | ||
| public void setup() { | ||
| if ((mFlags & FLAG_LAYOUT_IN_SCREEN_OLDER_DEVICES) == 0) { | ||
| mActivity.getWindow().setFlags( | ||
| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN | ||
| | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, | ||
| WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN | ||
| | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS); | ||
| } | ||
| } | ||
|
|
||
| @Override | ||
| public boolean isVisible() { | ||
| return mVisible; | ||
| } | ||
|
|
||
| @Override | ||
| public void hide() { | ||
| if ((mFlags & FLAG_FULLSCREEN) != 0) { | ||
| mActivity.getWindow().setFlags( | ||
| WindowManager.LayoutParams.FLAG_FULLSCREEN, | ||
| WindowManager.LayoutParams.FLAG_FULLSCREEN); | ||
| } | ||
| mOnVisibilityChangeListener.onVisibilityChange(false); | ||
| mVisible = false; | ||
| } | ||
|
|
||
| @Override | ||
| public void show() { | ||
| if ((mFlags & FLAG_FULLSCREEN) != 0) { | ||
| mActivity.getWindow().setFlags( | ||
| 0, | ||
| WindowManager.LayoutParams.FLAG_FULLSCREEN); | ||
| } | ||
| mOnVisibilityChangeListener.onVisibilityChange(true); | ||
| mVisible = true; | ||
| } | ||
| } |
| @@ -0,0 +1,141 @@ | ||
| package zpln.hackgeny.util; | ||
|
|
||
| import android.annotation.TargetApi; | ||
| import android.app.Activity; | ||
| import android.os.Build; | ||
| import android.view.View; | ||
| import android.view.WindowManager; | ||
|
|
||
| /** | ||
| * An API 11+ implementation of {@link SystemUiHider}. Uses APIs available in | ||
| * Honeycomb and later (specifically {@link View#setSystemUiVisibility(int)}) to | ||
| * show and hide the system UI. | ||
| */ | ||
| @TargetApi(Build.VERSION_CODES.HONEYCOMB) | ||
| public class SystemUiHiderHoneycomb extends SystemUiHiderBase { | ||
| /** | ||
| * Flags for {@link View#setSystemUiVisibility(int)} to use when showing the | ||
| * system UI. | ||
| */ | ||
| private int mShowFlags; | ||
|
|
||
| /** | ||
| * Flags for {@link View#setSystemUiVisibility(int)} to use when hiding the | ||
| * system UI. | ||
| */ | ||
| private int mHideFlags; | ||
|
|
||
| /** | ||
| * Flags to test against the first parameter in | ||
| * {@link android.view.View.OnSystemUiVisibilityChangeListener#onSystemUiVisibilityChange(int)} | ||
| * to determine the system UI visibility state. | ||
| */ | ||
| private int mTestFlags; | ||
|
|
||
| /** | ||
| * Whether or not the system UI is currently visible. This is cached from | ||
| * {@link android.view.View.OnSystemUiVisibilityChangeListener}. | ||
| */ | ||
| private boolean mVisible = true; | ||
|
|
||
| /** | ||
| * Constructor not intended to be called by clients. Use | ||
| * {@link SystemUiHider#getInstance} to obtain an instance. | ||
| */ | ||
| protected SystemUiHiderHoneycomb(Activity activity, View anchorView, int flags) { | ||
| super(activity, anchorView, flags); | ||
|
|
||
| mShowFlags = View.SYSTEM_UI_FLAG_VISIBLE; | ||
| mHideFlags = View.SYSTEM_UI_FLAG_LOW_PROFILE; | ||
| mTestFlags = View.SYSTEM_UI_FLAG_LOW_PROFILE; | ||
|
|
||
| if ((mFlags & FLAG_FULLSCREEN) != 0) { | ||
| // If the client requested fullscreen, add flags relevant to hiding | ||
| // the status bar. Note that some of these constants are new as of | ||
| // API 16 (Jelly Bean). It is safe to use them, as they are inlined | ||
| // at compile-time and do nothing on pre-Jelly Bean devices. | ||
| mShowFlags |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN; | ||
| mHideFlags |= View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | ||
| | View.SYSTEM_UI_FLAG_FULLSCREEN; | ||
| } | ||
|
|
||
| if ((mFlags & FLAG_HIDE_NAVIGATION) != 0) { | ||
| // If the client requested hiding navigation, add relevant flags. | ||
| mShowFlags |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION; | ||
| mHideFlags |= View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | ||
| | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION; | ||
| mTestFlags |= View.SYSTEM_UI_FLAG_HIDE_NAVIGATION; | ||
| } | ||
| } | ||
|
|
||
| /** | ||
| * {@inheritDoc} | ||
| */ | ||
| @Override | ||
| public void setup() { | ||
| mAnchorView.setOnSystemUiVisibilityChangeListener(mSystemUiVisibilityChangeListener); | ||
| } | ||
|
|
||
| /** | ||
| * {@inheritDoc} | ||
| */ | ||
| @Override | ||
| public void hide() { | ||
| mAnchorView.setSystemUiVisibility(mHideFlags); | ||
| } | ||
|
|
||
| /** | ||
| * {@inheritDoc} | ||
| */ | ||
| @Override | ||
| public void show() { | ||
| mAnchorView.setSystemUiVisibility(mShowFlags); | ||
| } | ||
|
|
||
| /** | ||
| * {@inheritDoc} | ||
| */ | ||
| @Override | ||
| public boolean isVisible() { | ||
| return mVisible; | ||
| } | ||
|
|
||
| private View.OnSystemUiVisibilityChangeListener mSystemUiVisibilityChangeListener | ||
| = new View.OnSystemUiVisibilityChangeListener() { | ||
| @Override | ||
| public void onSystemUiVisibilityChange(int vis) { | ||
| // Test against mTestFlags to see if the system UI is visible. | ||
| if ((vis & mTestFlags) != 0) { | ||
| if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) { | ||
| // Pre-Jelly Bean, we must manually hide the action bar | ||
| // and use the old window flags API. | ||
| mActivity.getActionBar().hide(); | ||
| mActivity.getWindow().setFlags( | ||
| WindowManager.LayoutParams.FLAG_FULLSCREEN, | ||
| WindowManager.LayoutParams.FLAG_FULLSCREEN); | ||
| } | ||
|
|
||
| // Trigger the registered listener and cache the visibility | ||
| // state. | ||
| mOnVisibilityChangeListener.onVisibilityChange(false); | ||
| mVisible = false; | ||
|
|
||
| } else { | ||
| mAnchorView.setSystemUiVisibility(mShowFlags); | ||
| if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) { | ||
| // Pre-Jelly Bean, we must manually show the action bar | ||
| // and use the old window flags API. | ||
| mActivity.getActionBar().show(); | ||
| mActivity.getWindow().setFlags( | ||
| 0, | ||
| WindowManager.LayoutParams.FLAG_FULLSCREEN); | ||
| } | ||
|
|
||
| // Trigger the registered listener and cache the visibility | ||
| // state. | ||
| mOnVisibilityChangeListener.onVisibilityChange(true); | ||
| mVisible = true; | ||
| } | ||
| } | ||
| }; | ||
| } |
| @@ -0,0 +1,32 @@ | ||
| <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android" | ||
| xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" | ||
| android:layout_height="match_parent" android:background="#0099cc" | ||
| tools:context=".FullscreenActivity"> | ||
|
|
||
| <!-- The primary full-screen view. This can be replaced with whatever view | ||
| is needed to present your content, e.g. VideoView, SurfaceView, | ||
| TextureView, etc. --> | ||
| <TextView android:id="@+id/fullscreen_content" android:layout_width="match_parent" | ||
| android:layout_height="match_parent" android:keepScreenOn="true" android:textColor="#33b5e5" | ||
| android:textStyle="bold" android:textSize="50sp" android:gravity="center" | ||
| android:text="@string/dummy_content" /> | ||
|
|
||
| <!-- This FrameLayout insets its children based on system windows using | ||
| android:fitsSystemWindows. --> | ||
| <FrameLayout android:layout_width="match_parent" android:layout_height="match_parent" | ||
| android:fitsSystemWindows="true"> | ||
|
|
||
| <LinearLayout android:id="@+id/fullscreen_content_controls" style="?metaButtonBarStyle" | ||
| android:layout_width="match_parent" android:layout_height="wrap_content" | ||
| android:layout_gravity="bottom|center_horizontal" | ||
| android:background="@color/black_overlay" android:orientation="horizontal" | ||
| tools:ignore="UselessParent"> | ||
|
|
||
| <Button android:id="@+id/dummy_button" style="?metaButtonBarButtonStyle" | ||
| android:layout_width="0dp" android:layout_height="wrap_content" | ||
| android:layout_weight="1" android:text="@string/dummy_button" /> | ||
|
|
||
| </LinearLayout> | ||
| </FrameLayout> | ||
|
|
||
| </FrameLayout> |
| @@ -0,0 +1,15 @@ | ||
| <resources> | ||
|
|
||
| <style name="FullscreenTheme" parent="android:Theme.Holo"> | ||
| <item name="android:actionBarStyle">@style/FullscreenActionBarStyle</item> | ||
| <item name="android:windowActionBarOverlay">true</item> | ||
| <item name="android:windowBackground">@null</item> | ||
| <item name="metaButtonBarStyle">?android:attr/buttonBarStyle</item> | ||
| <item name="metaButtonBarButtonStyle">?android:attr/buttonBarButtonStyle</item> | ||
| </style> | ||
|
|
||
| <style name="FullscreenActionBarStyle" parent="android:Widget.Holo.ActionBar"> | ||
| <item name="android:background">@color/black_overlay</item> | ||
| </style> | ||
|
|
||
| </resources> |
| @@ -0,0 +1,12 @@ | ||
| <resources> | ||
|
|
||
| <!-- Declare custom theme attributes that allow changing which styles are | ||
| used for button bars depending on the API level. | ||
| ?android:attr/buttonBarStyle is new as of API 11 so this is | ||
| necessary to support previous API levels. --> | ||
| <declare-styleable name="ButtonBarContainerTheme"> | ||
| <attr name="metaButtonBarStyle" format="reference" /> | ||
| <attr name="metaButtonBarButtonStyle" format="reference" /> | ||
| </declare-styleable> | ||
|
|
||
| </resources> |
| @@ -0,0 +1,5 @@ | ||
| <resources> | ||
|
|
||
| <color name="black_overlay">#66000000</color> | ||
|
|
||
| </resources> |
| @@ -0,0 +1,6 @@ | ||
| <resources> | ||
| <string name="app_name">hackgeny</string> | ||
|
|
||
| <string name="dummy_button">Dummy Button</string> | ||
| <string name="dummy_content">DUMMY\nCONTENT</string> | ||
| </resources> |
| @@ -0,0 +1,27 @@ | ||
| <resources> | ||
|
|
||
| <!-- Base application theme. --> | ||
| <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar"> | ||
| <!-- Customize your theme here. --> | ||
| </style> | ||
|
|
||
| <style name="FullscreenTheme" parent="android:Theme.NoTitleBar"> | ||
| <item name="android:windowContentOverlay">@null</item> | ||
| <item name="android:windowBackground">@null</item> | ||
| <item name="metaButtonBarStyle">@style/ButtonBar</item> | ||
| <item name="metaButtonBarButtonStyle">@style/ButtonBarButton</item> | ||
| </style> | ||
|
|
||
| <!-- Backward-compatible version of ?android:attr/buttonBarStyle --> | ||
| <style name="ButtonBar"> | ||
| <item name="android:paddingLeft">2dp</item> | ||
| <item name="android:paddingTop">5dp</item> | ||
| <item name="android:paddingRight">2dp</item> | ||
| <item name="android:paddingBottom">0dp</item> | ||
| <item name="android:background">@android:drawable/bottom_bar</item> | ||
| </style> | ||
|
|
||
| <!-- Backward-compatible version of ?android:attr/buttonBarButtonStyle --> | ||
| <style name="ButtonBarButton" /> | ||
|
|
||
| </resources> |
| @@ -0,0 +1,19 @@ | ||
| // Top-level build file where you can add configuration options common to all sub-projects/modules. | ||
|
|
||
| buildscript { | ||
| repositories { | ||
| jcenter() | ||
| } | ||
| dependencies { | ||
| classpath 'com.android.tools.build:gradle:1.2.3' | ||
|
|
||
| // NOTE: Do not place your application dependencies here; they belong | ||
| // in the individual module build.gradle files | ||
| } | ||
| } | ||
|
|
||
| allprojects { | ||
| repositories { | ||
| jcenter() | ||
| } | ||
| } |
| @@ -0,0 +1,18 @@ | ||
| # Project-wide Gradle settings. | ||
|
|
||
| # IDE (e.g. Android Studio) users: | ||
| # Gradle settings configured through the IDE *will override* | ||
| # any settings specified in this file. | ||
|
|
||
| # For more details on how to configure your build environment visit | ||
| # http://www.gradle.org/docs/current/userguide/build_environment.html | ||
|
|
||
| # Specifies the JVM arguments used for the daemon process. | ||
| # The setting is particularly useful for tweaking memory settings. | ||
| # Default value: -Xmx10248m -XX:MaxPermSize=256m | ||
| # org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 | ||
|
|
||
| # When configured, Gradle will run in incubating parallel mode. | ||
| # This option should only be used with decoupled projects. More details, visit | ||
| # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects | ||
| # org.gradle.parallel=true |
| @@ -0,0 +1,6 @@ | ||
| #Wed Apr 10 15:27:10 PDT 2013 | ||
| distributionBase=GRADLE_USER_HOME | ||
| distributionPath=wrapper/dists | ||
| zipStoreBase=GRADLE_USER_HOME | ||
| zipStorePath=wrapper/dists | ||
| distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-all.zip |
| @@ -0,0 +1,164 @@ | ||
| #!/usr/bin/env bash | ||
|
|
||
| ############################################################################## | ||
| ## | ||
| ## Gradle start up script for UN*X | ||
| ## | ||
| ############################################################################## | ||
|
|
||
| # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. | ||
| DEFAULT_JVM_OPTS="" | ||
|
|
||
| APP_NAME="Gradle" | ||
| APP_BASE_NAME=`basename "$0"` | ||
|
|
||
| # Use the maximum available, or set MAX_FD != -1 to use that value. | ||
| MAX_FD="maximum" | ||
|
|
||
| warn ( ) { | ||
| echo "$*" | ||
| } | ||
|
|
||
| die ( ) { | ||
| echo | ||
| echo "$*" | ||
| echo | ||
| exit 1 | ||
| } | ||
|
|
||
| # OS specific support (must be 'true' or 'false'). | ||
| cygwin=false | ||
| msys=false | ||
| darwin=false | ||
| case "`uname`" in | ||
| CYGWIN* ) | ||
| cygwin=true | ||
| ;; | ||
| Darwin* ) | ||
| darwin=true | ||
| ;; | ||
| MINGW* ) | ||
| msys=true | ||
| ;; | ||
| esac | ||
|
|
||
| # For Cygwin, ensure paths are in UNIX format before anything is touched. | ||
| if $cygwin ; then | ||
| [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` | ||
| fi | ||
|
|
||
| # Attempt to set APP_HOME | ||
| # Resolve links: $0 may be a link | ||
| PRG="$0" | ||
| # Need this for relative symlinks. | ||
| while [ -h "$PRG" ] ; do | ||
| ls=`ls -ld "$PRG"` | ||
| link=`expr "$ls" : '.*-> \(.*\)$'` | ||
| if expr "$link" : '/.*' > /dev/null; then | ||
| PRG="$link" | ||
| else | ||
| PRG=`dirname "$PRG"`"/$link" | ||
| fi | ||
| done | ||
| SAVED="`pwd`" | ||
| cd "`dirname \"$PRG\"`/" >&- | ||
| APP_HOME="`pwd -P`" | ||
| cd "$SAVED" >&- | ||
|
|
||
| CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar | ||
|
|
||
| # Determine the Java command to use to start the JVM. | ||
| if [ -n "$JAVA_HOME" ] ; then | ||
| if [ -x "$JAVA_HOME/jre/sh/java" ] ; then | ||
| # IBM's JDK on AIX uses strange locations for the executables | ||
| JAVACMD="$JAVA_HOME/jre/sh/java" | ||
| else | ||
| JAVACMD="$JAVA_HOME/bin/java" | ||
| fi | ||
| if [ ! -x "$JAVACMD" ] ; then | ||
| die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME | ||
| Please set the JAVA_HOME variable in your environment to match the | ||
| location of your Java installation." | ||
| fi | ||
| else | ||
| JAVACMD="java" | ||
| which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. | ||
| Please set the JAVA_HOME variable in your environment to match the | ||
| location of your Java installation." | ||
| fi | ||
|
|
||
| # Increase the maximum file descriptors if we can. | ||
| if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then | ||
| MAX_FD_LIMIT=`ulimit -H -n` | ||
| if [ $? -eq 0 ] ; then | ||
| if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then | ||
| MAX_FD="$MAX_FD_LIMIT" | ||
| fi | ||
| ulimit -n $MAX_FD | ||
| if [ $? -ne 0 ] ; then | ||
| warn "Could not set maximum file descriptor limit: $MAX_FD" | ||
| fi | ||
| else | ||
| warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" | ||
| fi | ||
| fi | ||
|
|
||
| # For Darwin, add options to specify how the application appears in the dock | ||
| if $darwin; then | ||
| GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" | ||
| fi | ||
|
|
||
| # For Cygwin, switch paths to Windows format before running java | ||
| if $cygwin ; then | ||
| APP_HOME=`cygpath --path --mixed "$APP_HOME"` | ||
| CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` | ||
|
|
||
| # We build the pattern for arguments to be converted via cygpath | ||
| ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` | ||
| SEP="" | ||
| for dir in $ROOTDIRSRAW ; do | ||
| ROOTDIRS="$ROOTDIRS$SEP$dir" | ||
| SEP="|" | ||
| done | ||
| OURCYGPATTERN="(^($ROOTDIRS))" | ||
| # Add a user-defined pattern to the cygpath arguments | ||
| if [ "$GRADLE_CYGPATTERN" != "" ] ; then | ||
| OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" | ||
| fi | ||
| # Now convert the arguments - kludge to limit ourselves to /bin/sh | ||
| i=0 | ||
| for arg in "$@" ; do | ||
| CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` | ||
| CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option | ||
|
|
||
| if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition | ||
| eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` | ||
| else | ||
| eval `echo args$i`="\"$arg\"" | ||
| fi | ||
| i=$((i+1)) | ||
| done | ||
| case $i in | ||
| (0) set -- ;; | ||
| (1) set -- "$args0" ;; | ||
| (2) set -- "$args0" "$args1" ;; | ||
| (3) set -- "$args0" "$args1" "$args2" ;; | ||
| (4) set -- "$args0" "$args1" "$args2" "$args3" ;; | ||
| (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; | ||
| (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; | ||
| (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; | ||
| (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; | ||
| (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; | ||
| esac | ||
| fi | ||
|
|
||
| # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules | ||
| function splitJvmOpts() { | ||
| JVM_OPTS=("$@") | ||
| } | ||
| eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS | ||
| JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" | ||
|
|
||
| exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" |
| @@ -0,0 +1,90 @@ | ||
| @if "%DEBUG%" == "" @echo off | ||
| @rem ########################################################################## | ||
| @rem | ||
| @rem Gradle startup script for Windows | ||
| @rem | ||
| @rem ########################################################################## | ||
|
|
||
| @rem Set local scope for the variables with windows NT shell | ||
| if "%OS%"=="Windows_NT" setlocal | ||
|
|
||
| @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. | ||
| set DEFAULT_JVM_OPTS= | ||
|
|
||
| set DIRNAME=%~dp0 | ||
| if "%DIRNAME%" == "" set DIRNAME=. | ||
| set APP_BASE_NAME=%~n0 | ||
| set APP_HOME=%DIRNAME% | ||
|
|
||
| @rem Find java.exe | ||
| if defined JAVA_HOME goto findJavaFromJavaHome | ||
|
|
||
| set JAVA_EXE=java.exe | ||
| %JAVA_EXE% -version >NUL 2>&1 | ||
| if "%ERRORLEVEL%" == "0" goto init | ||
|
|
||
| echo. | ||
| echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. | ||
| echo. | ||
| echo Please set the JAVA_HOME variable in your environment to match the | ||
| echo location of your Java installation. | ||
|
|
||
| goto fail | ||
|
|
||
| :findJavaFromJavaHome | ||
| set JAVA_HOME=%JAVA_HOME:"=% | ||
| set JAVA_EXE=%JAVA_HOME%/bin/java.exe | ||
|
|
||
| if exist "%JAVA_EXE%" goto init | ||
|
|
||
| echo. | ||
| echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% | ||
| echo. | ||
| echo Please set the JAVA_HOME variable in your environment to match the | ||
| echo location of your Java installation. | ||
|
|
||
| goto fail | ||
|
|
||
| :init | ||
| @rem Get command-line arguments, handling Windowz variants | ||
|
|
||
| if not "%OS%" == "Windows_NT" goto win9xME_args | ||
| if "%@eval[2+2]" == "4" goto 4NT_args | ||
|
|
||
| :win9xME_args | ||
| @rem Slurp the command line arguments. | ||
| set CMD_LINE_ARGS= | ||
| set _SKIP=2 | ||
|
|
||
| :win9xME_args_slurp | ||
| if "x%~1" == "x" goto execute | ||
|
|
||
| set CMD_LINE_ARGS=%* | ||
| goto execute | ||
|
|
||
| :4NT_args | ||
| @rem Get arguments from the 4NT Shell from JP Software | ||
| set CMD_LINE_ARGS=%$ | ||
|
|
||
| :execute | ||
| @rem Setup the command line | ||
|
|
||
| set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar | ||
|
|
||
| @rem Execute Gradle | ||
| "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% | ||
|
|
||
| :end | ||
| @rem End local scope for the variables with windows NT shell | ||
| if "%ERRORLEVEL%"=="0" goto mainEnd | ||
|
|
||
| :fail | ||
| rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of | ||
| rem the _cmd.exe /c_ return code! | ||
| if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 | ||
| exit /b 1 | ||
|
|
||
| :mainEnd | ||
| if "%OS%"=="Windows_NT" endlocal | ||
|
|
||
| :omega |
| @@ -0,0 +1,19 @@ | ||
| <?xml version="1.0" encoding="UTF-8"?> | ||
| <module external.linked.project.id="hackgeny" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$" external.system.id="GRADLE" external.system.module.group="" external.system.module.version="unspecified" type="JAVA_MODULE" version="4"> | ||
| <component name="FacetManager"> | ||
| <facet type="java-gradle" name="Java-Gradle"> | ||
| <configuration> | ||
| <option name="BUILD_FOLDER_PATH" value="$MODULE_DIR$/build" /> | ||
| <option name="BUILDABLE" value="false" /> | ||
| </configuration> | ||
| </facet> | ||
| </component> | ||
| <component name="NewModuleRootManager" inherit-compiler-output="true"> | ||
| <exclude-output /> | ||
| <content url="file://$MODULE_DIR$"> | ||
| <excludeFolder url="file://$MODULE_DIR$/.gradle" /> | ||
| </content> | ||
| <orderEntry type="inheritedJdk" /> | ||
| <orderEntry type="sourceFolder" forTests="false" /> | ||
| </component> | ||
| </module> |
| @@ -0,0 +1 @@ | ||
| include ':app' |
