I have an activity wich has a Toolbar which displays a back button.
<android.support.v7.widget.Toolbar
android:id="#+id/toolbar_about"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:background="?attr/colorPrimary"
android:minHeight="?attr/actionBarSize"
android:theme="?attr/actionBarTheme"
app:title="#string/app_name"
/>
The back button is enabled like this:
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar_about);
setSupportActionBar(toolbar);
//noinspection ConstantConditions
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
getSupportActionBar().setDisplayShowHomeEnabled(true);
I call this activity from my main activity like this:
Intent intent = new Intent(this, AboutActivity.class);
startActivity(intent);
The Activity's parent is defined in the manifest
<activity android:name=".AboutActivity">
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value=".EntryActivity" />
</activity>
So far everything works fine, except that the transition animation is wrong when using the back button in the Toolbar.
When I open the activity, it slides in from the right.
When I press the phone's physical back button it slides out to the right again. This is correct.
However when using the Toolbar back button it slides out to the left. This looks wrong. How can I change this, so it duplicates the behaviour of the physical back button?
When you press the Actionbar Up button, AppCompatActivity detects this button press in its onMenuItemSelected() call, and invokes onSupportNavigateUp(). This method determines the "parent activity" Intent and uses that to navigate up. Because it's using an Intent to (re-)open the previous activity, it uses the same animation it would for opening a "new" screen.
Assuming you don't care about the particular niceties of the "Up Navigation" pattern (which it sounds like you do not, as comments have led me to believe you don't have lateral navigation and you can't get to your second activity from anywhere other than your first activity), you can side-step all of this built-in "up" behavior by overriding the onSupportNavigateUp() method.
#Override
public boolean onSupportNavigateUp() {
finish();
return true;
}
This will mean that pressing the Actionbar Up button always simply finish()es your activity, so (like I said before) you lose out on all the smart built-in "up" behavior... but you didn't want that anyway.
You could also handle the Actionbar Up button in onOptionsItemSelected(), but I prefer the other way since I think it's a little more obvious that you're hijacking the system's up behavior.
#Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId() == android.R.id.home) {
finish();
return true;
}
return super.onOptionsItemSelected(item);
}
With either of these in place, you can remove the "parent" definitions from your manifest, since now they're not used.
Try this:
override fun onSupportNavigateUp(): Boolean {
onBackPressed()
return true
}
This is because the default launchMode of activities is standard.
The documentation of standard states the following:
The system always creates a new instance of the activity in the target task and routes the intent to it.
You can solve this by using android:launchMode="singleTop" on the parent/starting activity.
If an instance of the activity already exists at the top of the target task, the system routes the intent to that instance through a call to its onNewIntent() method, rather than creating a new instance of the activity.
For more information see Tasks and the back stack and android:launchMode.
I have added a Toolbar to my AboutApplication activity. I have also added a navigation button to this toolbar -
when this button is clicked, the application should navigate to the previous activity (LoginActivity).
I tried calling the finish inside method onBackPressed() and this did not work. I tried creating an OnClickEventListener() for the toolbar's setNavigationOnClickListener() - this did not work either.
Here is the code for my AboutApplication activity:
public class AboutApplicationActivity extends AppCompatActivity {
private NavigationOnClickListener myListener;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_about_application);
myListener = new NavigationOnClickListener(this);
myListener.setNextActivity(new LoginActivity());
TextView toolbarTitle = (TextView) findViewById(R.id.aboutApplication);
Toolbar toolbar = (Toolbar) findViewById(R.id.aboutApplicationToolbar);
toolbar.setNavigationIcon(R.drawable.back);
toolbar.setNavigationOnClickListener(myListener);
setSupportActionBar(toolbar);
getSupportActionBar().setDisplayShowTitleEnabled(false);
getSupportActionBar().setDisplayHomeAsUpEnabled(true);
}
Do not confuse what you want with Navigation Design, you are requirement matches a lot like Up navigation provided by android, why do you want to make it around when this feature is already provided to you.
if your AboutApplication Activity comes from LoginActivity then you should apply Up Navigation provided my Android which know the best, let it handle it.
Things that you need to take care of while you are providing up navigation is that you properly define the child-parent structure in the AndroidManifest.xml file in your android project
<!-- Assuming this activity would be a parent -->
<activity
android:name="com.example.myfirstapp.LoginActivity" ...>
...
</activity>
<!-- this would be your child activity in your case `AboutApplicationActivity` -->
<activity
android:name=".AboutApplicationActivity"
>
<!-- Parent activity meta-data to support 4.0 and lower -->
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value="com.example.myfirstapp.LoginActivity" />
</activity>
now in your child activity things you need to make sure is this,
getActionBar().setDisplayHomeAsUpEnabled(true); // without support library
getSupportActionBar().setDisplayHomeAsUpEnabled(true); // support library
and offcours by now you know where does this goes
#Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
// Respond to the action bar's Up/Home button
case android.R.id.home:
NavUtils.navigateUpFromSameTask(this);
return true;
}
return super.onOptionsItemSelected(item);
}
if you have hard time importing NavUtils.java, than write its fully qualified name android.support.v4.app.NavUtils
for more details use android documentation here,
I have a simple app that displays text.
The app starts with a main screen with a few options (ex. an info button that leads to info about the app, a browse button that allows the user to see all the individual pieces of text that can be displayed). The main button leads to another screen where text is displayed. By swiping left and right he can see different passages of text. This is the main purpose of the app.
Currently I have an ActionBar implemented. My MainActivity.Java extends AppCompatActivity. Everything in the app is in this activity.
Now I want to make it so the ActionBar appears only in "Display" mode, not in the start up screen, or "info" / "browse" mode.
Is it possible to have an ActionBar in one part of the app, and no ActionBar in another part of the app? (And keep it all in the same activity?)
I've been trying to accomplish this without avail. If this is possible, what should I try next?
So far, I've attempted the following:
1) Create this theme
<style name="Theme.AppCompat.NoActionBar" parent="Theme.AppCompat.Light">
<item name="android:windowActionBar">false</item>
<item name="android:windowNoTitle">true</item>
</style>
And apply it to MainActivity ...
<activity
android:name=".MainActivity"
android:label="#string/app_name"
android:theme="#style/Theme.AppCompat.NoActionBar" >
....
After doing this, the ActionBar was still there. (This comes from this S.O. post (android:windowNoTitle will not hide actionbar with appcompat-v7 21.0.0)
2) Another attempt was to add this to onCreate.
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
getActionBar().hide();
setContentView(R.layout.activity_main);
This came from studying this S.O. post: (How to hide action bar before activity is created, and then show it again?)
Any suggestions?
In the activities where you want to have no action bar use a theme derived from Theme.AppCompat.NoActionBar or Theme.AppCompat.Light.NoActionBar. This activity will never be able to show the action bar unless you supply your own via setSupportActionBar(Toolbar).
In the activities where you want to have the action bar use a theme derived from Theme.AppCompat, Theme.AppCompat.Light or Theme.AppCompat.Light.DarkActionBar. This will allow you to dynamically hide or show the action bar in such activity. You will not be able to supply your own action bar using these themes.
When working with appcompat-v7 action bar you need to obtain it by calling getSupportActionBar() instead of getActionBar().
You can hide and show the ActionBar programatically.
To hide
getSupportActionBar().hide();
To Show
getSupportActionBar().show();
It can also be done from Fragments
To hide
getActivity().getSupportActionBar().hide();
To Show
getActivity().getSupportActionBar().show();
Edit:
As noted by #RenniePet,
You need to call ((AppCompatActivity)getActivity()).getSupportActionBar(), if you're using Toolbar as the ActionBar.
Extend you activity as AppCompatActivity and then use action bar as:-
getSupportActionBar().hide(); // for hiding
getSupportActionBar().show(); // for showing
<style name="Theme.AppCompat.NoActionBar" parent="Theme.AppCompat.Light">
<item name="android:windowActionBar">false</item>
<item name="android:windowNoTitle">true</item>
</style>
remove android in item windowActionbar.just like follow:
<style name="Theme.AppCompat.NoActionBar" parent="Theme.AppCompat.Light">
<item name="windowActionBar">false</item>
<item name="android:windowNoTitle">true</item>
</style>
I hope it can help you.
AppCompatActivity has its own embedded toolbar. You dont need to use extra toolbar definition in your main xml.
just call getSupportActionBar().show()
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getSupportActionBar().show();
}
public boolean onCreateOptionsMenu(Menu menu)
{
getMenuInflater().inflate(R.menu.menu_main, menu);
return super.onCreateOptionsMenu(menu);
}
#Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
TextView text1=(TextView)findViewById(R.id.textView);
text1.setText("I changed the text!");
}
return super.onOptionsItemSelected(item);
}
In onCreate method, after setContentView, use this simply to show or hide for each class.
getSupportActionBar().hide();
getSupportActionBar().show();
If you want to set title,
getSupportActionBar().setTitle("This is ToolBar");
I hope this can be solution. It worked on my system:
android:theme="#android:style/Theme.NoTitleBar.Fullscreen"
Dismiss ToolBar for all activities with AppTheme:
styles.xml:
<style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar"><!-- .NoActionBar -->
If you are trying to show/hide the ActionBar of an INTENT with AppCompatActivity and you get the following issues:
pointer null exception ...
thread issue ...
Follow these steps to access to the same relevant thread into the intent:
// 1) Calling the intent in the "main activity"
Intent intent = new Intent(context, YourClass.class);
startActivity(intent);
// 2) Get the context in your "Intent activity"
public class YourClass extends AppCompatActivity {
YourClass mContext;
#Override
protected void onCreate(Bundle savedInstanceState) {
mContext = this;
}
// 3) Hide/Show Action bar from a method
public void yourMethod(YourClass mContext){
mContext.runOnUiThread(new Runnable() {
#Override
public void run() {
mContext.getSupportActionBar().hide();
}
});
}
I am using ActionBarSherlock (ABS) and would like to add a dialog to my application as one can see in the ABS Demos Sample application provided by the project. The dialog sample look like this:
I created an activity myself. Here is relevant source code:
public class Dialog extends SherlockActivity {
#Override
public void onCreate(Bundle savedInstanceState) {
setTheme(R.style.Sherlock___Theme_DarkActionBar);
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_dialog);
}
}
For some reason, Android forces me to add setTheme() although the ABS sample does not do this. If I leave it out, I will run into the following error.
java.lang.IllegalStateException: You must use Theme.Sherlock, Theme.Sherlock.Light, Theme.Sherlock.Light.DarkActionBar, or a derivative.
My AndroidManifest.xml has the following settings, which are very similar to the ones from the ABS sample.
<activity
android:name=".activities.Dialog"
android:label="#string/title_activity_dialog"
android:theme="#style/Theme.Sherlock.Dialog" >
</activity>
The following screenshot shows how my dialog activity looks like.
I am using ActionBarSherlock 4.1.0 with maps support, the Android Support library v4.
Question: Can you figure out, why it looks so different?
Dark vs. light user interface
Transparent vs. opaque background
With and without actionbar
Update:
The ABS sample starts the dialog activity as follows:
protected void onListItemClick(ListView l, View v, int position, long id) {
Map<String, Object> map = (Map<String, Object>)l.getItemAtPosition(position);
Intent intent = (Intent) map.get("intent");
startActivity(intent);
}
I start the dialog activity as follows:
public boolean onCreateOptionsMenu(Menu menu) {
menu.add(R.string.title_menuItemDialogActivtiy)
.setIcon(R.drawable.ic_action_dialog)
.setIntent(new Intent(this, Dialog.class))
.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
return true;
}
Meanwhile, I saw that this pattern is deprecated. Instead, I could use a DialogFragment. The question that occurs here: How can I integrate the fragment with the action menu item?
Alternative solution:
I decided to use a DialogFragment instead of an Activity as I estimate it to be more "future-safe". I basically followed the very informative tutorial Using DialogFragments (posted June 3, 2012), which I like to recommend as perfect starting point for any interest reader. Further, I like to add related and useful posts:
Validating user input
Softkeyboard vs. separate DONE button
The output you are seeing definitely comes from setting the Theme in Java code (which will override the value set in XML). I just stood up the following sample application (this is literally all there is) and replicated the issue by adding the extra setTheme() call.
<application android:icon="#drawable/icon" android:label="#string/app_name">
<activity android:name=".Dialog"
android:theme="#style/Theme.Sherlock.Dialog">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
And the Dialog...
public class Dialog extends SherlockActivity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView text = new TextView(this);
text.setText("This is a dialog!");
setContentView(text);
}
}
Now as to why you got an exception without that extra method, that's another matter (and quite strange). As you can see it should work with as little code as I provided above.
Perhaps make sure that both the library project and your project are being compiled with at least Android 4.0 (API 14) as this is a requirement of the library.
Beyond that, if you just want to show a Dialog in your application, does it need to be a themed Activity? This is not common. You can always create a simple Dialog or AlertDialog subclass to display as well. Take a look here for more information...
Try setting a theme for the application.
<application
android:theme="#style/Theme.Sherlock"
The dialogue should inherit the theme. If you've already set that then remove the android:theme tag in the activity declaration and the setTheme() call and see what happens. The reason you get the error without setTheme is because SherlockActivities must have one of the themes in the error message and you had it set to something else in the manifest setTheme() overrode this before you got into trouble.
I need to implement splash screen in my honeycomb app.
I use this code in activity's onCreate to show splash:
setContentView(R.layout.splash);
getActionBar().hide();
and this code to show main UI after sometime:
setContentView(R.layout.main);
getActionBar().show();
But before onCreate is called and splash appears, there is small amount of time when action bar shown.
How can I make action bar invisible?
I tried to apply theme to activity without action bar:
<item name="android:windowActionBar">false</item>
but in that case getActionBar() always returns null and I found no way to show it again.
Setting android:windowActionBar="false" truly disables the ActionBar but then, as you say, getActionBar(); returns null.
This is solved by:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
getActionBar().hide();
setContentView(R.layout.splash); // be sure you call this AFTER requestFeature
This creates the ActionBar and immediately hides it before it had the chance to be displayed.
But now there is another problem. After putting windowActionBar="false" in the theme, the Activity draws its normal Window Title instead of an ActionBar.
If we try to avoid this by using some of the *.NoTitleBar stock themes or we try to put <item name="android:windowNoTitle">true</item> in our own theme, it won't work.
The reason is that the ActionBar depends on the Window Title to display itself - that is the ActionBar is a transformed Window Title.
So the trick which can help us out is to add one more thing to our Activity theme xml:
<item name="android:windowActionBar">false</item>
<item name="android:windowTitleSize">0dp</item>
This will make the Window Title with zero height, thus practically invisible .
In your case, after you are done with displaying the splash screen you can simply call
setContentView(R.layout.main);
getActionBar().show();
and you are done. The Activity will start with no ActionBar flickering, nor Window Title showing.
ADDON:
If you show and hide the ActionBar multiple times maybe you have noticed that the first showing is not animated. From then on showing and hiding are animated. If you want to have animation on the first showing too you can use this:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
requestWindowFeature(Window.FEATURE_ACTION_BAR);
// delaying the hiding of the ActionBar
Handler h = new Handler();
h.post(new Runnable() {
#Override
public void run() {
getActionBar().hide();
}
});
The same thing can be achieved with:
protected void onPostResume() {
super.onPostResume();
getActionBar().hide();
but it may need some extra logic to check if this is the first showing of the Activity.
The idea is to delay a little the hiding of the ActionBar. In a way we let the ActionBar be shown, but then hide it immediately. Thus we go beyond the first non-animated showing and next showing will be considered second, thus it will be animated.
As you may have guessed there is a chance that the ActionBar could be seen before it has been hidden by the delayed operation. This is actually the case. Most of the time nothing is seen but yet, once in a while, you can see the ActionBar flicker for a split second.
In any case this is not a pretty solution, so I welcome any suggestions.
Addition for v7 support actionbar user, the code will be:
getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
getSupportActionBar().hide();
Using this simple code in your .class file to hide action bar
getSupportActionBar().hide();
If you are using ActionBarSherlock, then use Theme.Sherlock.NoActionBar Theme in your Activity
<activity
android:name=".SplashScreenActivity"
android:theme="#style/Theme.Sherlock.NoActionBar">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
Create two styles:
<style name="AppThemeNoBar" parent="Theme.AppCompat.Light">
<item name="android:windowNoTitle">true</item>
</style>
<style name="AppThemeBar" parent="Theme.AppCompat.Light">
<item name="android:windowNoTitle">false</item>
</style>
Set AppThemeNoBar as application theme and AppThemeBar to the activity where you want to show the ActionBar.
Using two styles you wont see the Action bar while views are loading.
Check this link Android: hide action bar while view load
Hi I have a simple solution by using 2 themes
Splash screen theme (add it to the manifest):
<style name="SplashTheme" parent="#android:style/Theme.Holo.NoActionBar">
<item name="android:windowBackground">#color/red</item>
</style>
normal theme (add it in your activity by setTheme(R.style.Theme)):
<style name="Theme" parent="#style/Theme.Holo"> <item name="android:windowBackground">#color/blue</item>
</style>
To support SDK 10:
#Override
public void onCreate(Bundle savedInstanceState) {
setTheme(R.style.Theme);
super.onCreate(savedInstanceState);
...........
...........
}
I was also trying to hide Action Bar on Android 2.2, but none of these solution worked. Everything ends with a crash. I checked the DDMS LOg, It was telling me to use 'Theme.AppCompat'.At last I Solved the problem by changing the android:theme="#android:style/Theme.Holo.Light.NoActionBar"Line
into android:theme="#style/Theme.AppCompat.NoActionBar"and it worked, but the the Interface was dark.
then i tried android:theme="#style/Theme.AppCompat.Light.NoActionBar" and finally got what i wanted.
After that when I Searched about 'AppCompat' on Developer Site I got This.
So I think the Solution for Android 2.2 is
<activity
android:name=".MainActivity"
android:theme="#style/Theme.AppCompat.Light.NoActionBar" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
And Sorry for my bad English Like Always.
Best result to me was to create an activity with ThemeNoTitleBar and without content as launcher. Then this activity call directly to the other.
Of course if you want you can add content to the Splash Activity but in my case I just wanted to show application directly.
Manifest:
<activity
android:name="com.package.SplashActivity"
android:theme="#android:style/Theme.Black.NoTitleBar" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
Activity:
public class SplashActivity extends Activity{
#Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
//start StartActivity
Intent intent = new Intent(this, StartActivity.class);
startActivity(intent);
finish();
}
}
If you use one Activity included a splash screen, then you can do this if you use SherlockActionBar
getSupportActionBar().hide();
After the splash screen you can show it again with ...
getSupportActionBar().show();
It should be the same with native ActionBar of Android.
#Clerics solution works. But this appears to also be an issue with some of googles native apps: googles, play store, talk. Also other big apps like skype.
EDIT: Bellow solution have given me problem for actionbarsherlock on api < 4.0, the reason being setTheme doesn't work pre ice cream sandwich
Add following in your manifest within you application or activity tags:
android:theme="#style/Theme.NoActionBar"
And then in your main activity:
// Set theme
setTheme(R.style.YOUR_THEME);
getSupportActionBar().setTitle(R.string.title);
// Start regular onCreate()
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
best and simple
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
2015, using support v7 library with AppCompat theme, set this theme for your Activity.
<style name="AppTheme.AppStyled" parent="Theme.AppCompat.Light.DarkActionBar">
<item name="colorPrimaryDark">#color/md_indigo_100</item>
<item name="colorPrimary">#color/md_indigo_500</item>
<item name="colorAccent">#color/md_red_500</item>
<item name="android:textColorPrimary">#color/md_white_1000</item>
<item name="android:textColor">#color/md_purple_500</item>
<item name="android:textStyle">bold</item>
<item name="windowNoTitle">true</item>
<item name="windowActionBar">false</item>
</style>
For Splashscreen you should use this line in manifest and don't use getActionBar()
<item name="android:windowActionBar">false</item>
and once when Splash Activity is finished in the main Activity use below or nothing
<item name="android:windowActionBar">true</item>
Try this, it works for me:
Below gets rid of activity's title bar
requestWindowFeature(Window.FEATURE_NO_TITLE);
Below eliminates the notification bar to make the activity go full-screen
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
(Full Example Below)
Take note: These methods were called before we set the content view of our activity
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Sets Application to full screen by removing action bar
requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
setContentView(R.layout.activity_main);
// without this check, we would create a new fragment at each orientation change!
if (null == savedInstanceState)
createFragment();
}
this may be handy
add this to your manifest
android:theme="#android:style/Theme.Light.NoTitleBar"
cheers
The best way I find after reading all the available options is set main theme without ActionBar and then set up MyTheme in code in parent of all Activity.
Manifest:
<application
...
android:theme="#android:style/Theme.Holo.Light.NoActionBar"
...>
BaseActivity:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setTheme(R.style.GreenHoloTheme);
}
This way helps me to avoid ActionBar when application start!
The solutions already posted came with the sideffect, that the first .show() call did not animate the ActionBar for me.
I got another nice solution, which fixed that:
Create a transparent drawable - something like that:
<shape xmlns:android="http://schemas.android.com/apk/res/android">
<solid
android:color="#00000000" />
</shape>
Set the actual actionbar background to a invisible custom view which you set on the actionbar:
getSupportActionBar().setCustomView(R.layout.actionbar_custom_layout);
getSupportActionBar().setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM,
ActionBar.DISPLAY_SHOW_CUSTOM | ActionBar.DISPLAY_SHOW_HOME | ActionBar.DISPLAY_SHOW_TITLE);
Set the transparent background for the actionbar in onCreate:
getSupportActionBar().setBackgroundDrawable(getResources().getDrawable(R.drawable.background_transparent));
Imortant: Don't hide the actionbar immediately in onCreate, but with a little delay later - e.g. when the layout is finished with creation:
getWindow().getDecorView().getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
#Override
public void onGlobalLayout() {
getSupportActionBar().hide();
}
});
Before your first .show() call set the custom view visible:
_actionbarRoot.setVisibility(View.VISIBLE);
getSupportActionBar().show();
In case you have null because you are using the support library, instead of getActionBar() you need to call getSupportActionBar().
Just add this to your MainActivity in the onCreate function.
val actionBar = supportActionBar?.apply { hide() }
Put your splash screen in a separate activity and use startActivityForResult from your main activity's onCreate method to display it. This works because, according to the docs:
As a special case, if you call startActivityForResult() with a requestCode >= 0 during the initial onCreate(Bundle savedInstanceState)/onResume() of your activity, then your window will not be displayed until a result is returned back from the started activity. This is to avoid visible flickering when redirecting to another activity.
You should probably do this only if the argument to onCreate is null (indicating a fresh launch of your activity, as opposed to a restart due to a configuration change).
I had still error with null pointer and finally it helped when I called first getWindow().requestFeature() and then super.onCreate()
public void onCreate(Bundle savedInstanceState) {
getWindow().requestFeature(Window.FEATURE_ACTION_BAR);
super.onCreate(savedInstanceState);
getActionBar().show();
Just add this in your styles.xml
<item name="android:windowNoTitle">true</item>
Actually, you could simply set splash Activity with NoActionBar
and set your main activity with action bar.
The best way to do this is two make the first activity as blank activity and the content you want to put and then after some time fire another activity.
By following this way you can make the first activity as your splash screen without action bar or anything.
Heres my first activity
package com.superoriginal.rootashadnasim.syllabus;
import android.content.Intent;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class first_screen extends AppCompatActivity {
#Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_first_screen);
final Handler h=new Handler();
h.postDelayed(new Runnable() {
#Override
public void run() {
Intent intent=new Intent(getApplicationContext(),DrawerChooseBranchMainActivity.class);
startActivity(intent);
}
},2000);
}
}
After that you can put any of your activity as first activity
If you want no action bar in any screen then just add this in your styles
<item name="windowActionBar">false</item>
<item name="windowNoTitle">true</item>
Android studio provide in build template for full screen, if you use Android studio you can follow below step to implement full screen activity.
Done. Android studio did your job, now you can check code for full screen.
this is the best way I used
Go to java file, after onCreate:
#Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// Take instance of Action Bar
// using getSupportActionBar and
// if it is not Null
// then call hide function
if (getSupportActionBar() != null) {
getSupportActionBar().hide();
}
}
I realise that posting links are not the best way to do things, but I highly recommend you read the following documentation from Google themselves. This is the official android doc on how to control your system ui (things like actionbar, nav bar etc). Unfortunately the info is too much to post directly, but after reading this you will understand exactly how to show and hide features no matter what version you are developing for, its so simple!
Incase the link ever changes, it can be found under the official android documentation under training -> getting started -> Best practices for user interface -> managing the system ui
https://developer.android.com/training/system-ui/index.html
you can use this :
getSupportActionBar().hide(); if it doesn't work try this one :
getActionBar().hide();
if above doesn't work try like this :
in your directory = res/values/style.xml , open style.xml -> there is attribute parent change to parent="Theme.AppCompat.Light.DarkActionBar"
if all of it doesn't work too. i don't know anymore. but for me it works.