This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
Android : Save application state on screen orientation change
In my app I have a listView. When starts application it automitacally loaded all phone contacts that exists in that phone. So when rotate my phone it's start load again, every time I rotate device it is start reading again and again. What should I do here, so I the contacts load just one time and even I rotate the phone.
android:configChanges = "orientation"
add this tag in your activity in manifest file.
Return the data in onRetainNonConfigurationInstance() and retrieve it in your onCreate() using getLastNonConfigurationInstance()
If getLastNonConfigurationInstance() returns null, request the data again.
These two functions are designed to be used to save data between instances of the same activity being recreated because of a configuration change like orientation.
As mentioned, you can alternatively stop Android destroying / recreating your activity on such a configuration change by adding the events you want to manually handle to android:configChanges = "XXX" in the activity tag in your manifest. This is suitable if you don't require different assets / layouts etc. when in portrait and landscape.
However, if you only add orientation to configChanges, you might experience the same problem when another event triggers the activity to be recreated - check out: Handling run time changes
You should use a 'Content Provider'. The provider will handle loading and will handle rotaions, onPauses and such. I made a frontend for a spanish digg like page and had the same problem. Here is the project so you can have a look at how you can solve the problem: http://code.google.com/p/meneameandroid/
Wanted to add some more to Yashwanth Kumar's ans. like you need to Override the OnConfigurationChange method in the activity where you are loading the content.
Related
in my application (minSdkVersion 17, but I am flexible concerning this), I have a single activity. It displays some kind of timetable. I want to let it show the current day and scroll to the correct time.
This functionality is already working perfectly fine.
I want to do this everytime when the app is started, or everytime when the app becomes active again (e.g. after pressing the home button and just clicking the app icon again without killing the app inbetween).
But I do NOT want to do this, when the device is rotated.
For example, I have a method:
private void scrollToNow() {
// do the calculation and scroll all views to the correct position
// this is code I already have fully functional!
}
And I want to execute it every time the activity gets active again, but NOT on orientation change.
I tried a lot of combinations (in onStart, onResume, onCreate), but none of them did the trick. I tried to build a solution using the savedInstanceState but failed.
Anybody got some tips or useful links for me?
Thanks alot,
Oliver
Please, think twice before you decide to check configuration changes manually.
If your application doesn't need to update resources during a specific configuration change and you have a performance limitation that requires you to avoid the activity restart, then you can declare that your activity handles the configuration change itself, which prevents the system from restarting your activity.
Note: Handling the configuration change yourself can make it much more difficult to use alternative resources, because the system does not automatically apply them for you. This technique should be considered a last resort when you must avoid restarts due to a configuration change and is not recommended for most applications.
Try to save some flag in onSaveInstanceState and in onCreate check if there is savedInstanceState, then save it as field for example. This will give you information about does activity is 'recreated' or not. Then in 'onResume' check is this flag set or not. If not, then you are not 'recreated' your activity, so you can invoke scrollToNow()
I dont want to recreate layout when screen orientation change
Did you tried to add this line to your AndroidManifest.xml android:configChanges="screenLayout|screenSize|orientation" like that :
<activity
android:name="youractivity"
android:configChanges="screenLayout|screenSize|orientation"
android:label="#string/title_activity_create_note"
android:theme="#style/AppTheme"
android:windowSoftInputMode="stateAlwaysHidden" />
For more information you can take a look at : manifest/activity-element in that page go to android:configChanges section and read please .
When adding this you must handle onConfigurationChanged() method by yourself instead of Android System.
Please read carefully Note section in that page :
Note: Using this attribute should be avoided and used only as a last resort. Please read Handling Runtime Changes for more information about how to properly handle a restart due to a configuration change.
Also i am using this in my application maybe you can try this too : android:screenOrientation="nosensor" in that page you can find information about it too.
This question already has answers here:
Activity restart on rotation Android
(34 answers)
Closed 8 years ago.
So this is my first app on android and it's working great. However, when I tilt the screen to its horizontal view then my integers get reset to zero. If I start horizontally then switch it to vertical, it resets the integers to zero too. How can I get it to not reset and just switch?
Override onSaveInstanceState(Bundle outState) method. Put your data in outState bundle, and then, in onCreate(Bundle savedInstanceState), extract it from savedInstanceState.
If your data is something more complex than a trivial integer, and does not implement Parcelable interface, use Fragment.
Your app will re-run an activity each time you tilt the device. You have to save the data in a shared preferences file before you rotate, because a rotate will kill the activity so that it can run again with the new orientation.
See this link on how to store the data: http://developer.android.com/reference/android/app/Activity.html#SavingPersistentState
If you don't want to save your data one quick 'fix' for this is to go into your AndroidManifest.xml file and do the following:
Select the activity (I'm assuming it's your MainActivity)
Find the field labeled 'screen orientation'
Change it to 'portrait' (to keep the screen from changing when the phone is tilted horizontally)
You can also do this in the xml of your AndroidManifest file which would look something like this:
<activity
...
android:name="yourApp.MainActivity"
android:screenOrientation="portrait"
...
</activity>
Edit - Keeping in mind that
"this is my first app on android"
Locking the orientation is a perfectly reasonable way to stop this behavior if you're just testing things out but it is by no means a viable solution in any 'real' project.
I have problem with my activity
when I change the phone's orientation, the activity runs the onCreate method agaian
(and my program downloads a file in onCreate)
how can I make activity not restart after orientation change ?
This is the default behaviour for Android Activities - They get recreated whenever you change the device configuration.
To change this behaviour, add this line to the Activity declaration in your AndroidManifest.xml:
android:configChanges="orientation|keyboardHidden|screenSize"
This will tell the system that you handle orientation changes for your Activity on your own.
android:configChanges is good, if you're not changing anything, when orientation of activity will be changed.
You can also read about handling orientation change in documentation:this and this
You should properly handle you configuration changes, you can use onSaveInstanceState to store information that given file was already downloaded - ie. with path to it. In onCreate Bundle savedInstanceState will be non null after configuration change, you can read information on your downloaded file from it.
If you will use android:configChanges, then it will not solve your problem. Once you go to other app, android might destroy your activity, when you will go back to your app, android will recreate it again - and you again will start downloading your file.
I have a method in my main class, that fetches some data from the internet. The thing is that after everything is done, if I change the screen orientation by moving the device, everything starts allover again(fetching data while displaying a loading screen). Is there somewhere I could put my method so that if my device's screen orientation changes, it won't erase everything that has been done until that moment? Thanks.
What is happening to you is that every time you rotate your activity is recreated, as per android good practices you should handle your activity being recreated because android may destroy your activity at any point if resources go low on the device. Take a look at saving the state of your activity and how to restore it and the link.
Example using onSaveInstanceState()
You can use a singleton class to store your data.
If you prefer a simpler way you can also put your data as static, so the orientation change will not throw them away.
I think that your Activity is getting recreated again. In that case,it will load again.
1). You can handle orientation change by overriding
public void onConfigurationChanged(Configuration newConfig)
and in your activity declaration in manifest file add the following line
android:configChanges="orientation|screenSize|keyboardHidden"
2). As Aerilys said in the above answer, you can use singleton class to store data. Before displaying your loading screen check if you single ton object has data or not. If yes then skip displaying your loading screen
I have been going gaga to figure this out.
Although I have read a lot that on Orientation Change, Android kills an activity and starts it as a fresh one, and the only way to handle this is to save all the stuff inside onSaveInstanceState() and try to restore it inside onCreate().
But my activity does a lot and different kind of network activities at different times and if the orientation is changed when the network activity is being performed, I'll have to handle a lot of different and complex scenarios.
Is there any simple way to just point Android that this activity doesn't need to be redrawn at all when the orientation is changed so that it automatically saves all the data and re-uses it?
I wonder if there's any thing like that.
Yes, you can add attribute android:configChanges="orientation" to the activity declaration in the AndroidManifest.xml file.
EDIT:
The purpose of the android:configChanges attribute is to prevent an activity from being recreated when it's really necessary. For example the Camera application uses this attribute because it the camera preview screen mustn't be recreated when an orientation change happens. Users expect the camera preview to work without any delays when they rotate their devices and camera initialization is not a very fast process. So it's kind of a native behavior for the Camera application to handle orientation changes manually.
For most applications it doesn't really matter if an activity is recreated or not during orientation changes. But sometimes it's more convenient to persist an activity during this process because of slow activity creation, asynchronous tasks performed by an activity or some other reasons. In this case it's possible to tweak an application a little and to use the android:configChanges="orientation" attribute. But what is really important to understand when you use this tweak is that you MUST implement methods for saving and restoring a state properly!
So to sum up this answer, the android:configChanges can allow you to improve the performance of an application or to make it behave "natively" in some rare cases but it doesn't reduce the amount of code you have to write.
But my activity does a lot and different kind of network activities at different times and if the orientation is changed when the network activity is being performed, I'll have to handle a lot of different and complex scenarios.
Then move that logic out of the activity and into a service.
Yes, you can add attribute
android:configChanges="orientation" to
the activity declaration in the
AndroidManifest.xml file.
IMHO, it's better to declare
android:configChanges="orientation|keyboard|keyboardHidden"
About the blog post you gave the link in another answers. I guess here is the answer:
If your application doesn't need to
update resources during a specific
configuration change and you have a
performance limitation that requires
you to avoid the Activity restart,
then you can declare that your
Activity handles the configuration
change itself, which prevents the
system from restarting your Activity.
I spoke as well with an android developer about this problem. And he meant following. If you don't have different layouts for landscape and portrait orientation, you can easy use configChanges.
I solved my problem by adding this to my activity in my manifest file
android:configChanges="keyboardHidden|orientation|screenSize"
Just answered this question earlier: Android - screen orientation reloads activity
In your case you want to completely prevent Android from killing your Activity. You'll need to update your manifest to catch the orientation change, then implement the orientation change callback to actually do whatever you need to do (which may be nothing) when an orientation change occurs.
if you are doing a lot of networking inside Asynchronous task maybe you should use onRetainNonConfigurationInstance()
ans then get the data back in your onCreate() method like this tutorial or this
add android:configChanges="orientation" to your activity in manifest and add this code in your activity class and check..i hope it will help for you.
#Override
public void onConfigurationChanged(Configuration newConfig)
{
super.onConfigurationChanged(newConfig);
setContentView(R.layout.main);
}
this method will be called when orientation is changed nothing else if u don't want to change anything let it be blank
android:screenOrientation="portrait" in the activity tag in the manifest will lock your orientation.
Check this link for more inforation.