How to recreate activity android

Recreating an Activity

This lesson teaches you to

You should also read

There are a few scenarios in which your activity is destroyed due to normal app behavior, such as when the user presses the Back button or your activity signals its own destruction by calling finish() . The system may also destroy your activity if it’s currently stopped and hasn’t been used in a long time or the foreground activity requires more resources so the system must shut down background processes to recover memory.

When your activity is destroyed because the user presses Back or the activity finishes itself, the system’s concept of that Activity instance is gone forever because the behavior indicates the activity is no longer needed. However, if the system destroys the activity due to system constraints (rather than normal app behavior), then although the actual Activity instance is gone, the system remembers that it existed such that if the user navigates back to it, the system creates a new instance of the activity using a set of saved data that describes the state of the activity when it was destroyed. The saved data that the system uses to restore the previous state is called the «instance state» and is a collection of key-value pairs stored in a Bundle object.

Caution: Your activity will be destroyed and recreated each time the user rotates the screen. When the screen changes orientation, the system destroys and recreates the foreground activity because the screen configuration has changed and your activity might need to load alternative resources (such as the layout).

By default, the system uses the Bundle instance state to save information about each View object in your activity layout (such as the text value entered into an EditText object). So, if your activity instance is destroyed and recreated, the state of the layout is restored to its previous state with no code required by you. However, your activity might have more state information that you’d like to restore, such as member variables that track the user’s progress in the activity.

Note: In order for the Android system to restore the state of the views in your activity, each view must have a unique ID, supplied by the android:id attribute.

To save additional data about the activity state, you must override the onSaveInstanceState() callback method. The system calls this method when the user is leaving your activity and passes it the Bundle object that will be saved in the event that your activity is destroyed unexpectedly. If the system must recreate the activity instance later, it passes the same Bundle object to both the onRestoreInstanceState() and onCreate() methods.

Figure 2. As the system begins to stop your activity, it calls onSaveInstanceState() (1) so you can specify additional state data you’d like to save in case the Activity instance must be recreated. If the activity is destroyed and the same instance must be recreated, the system passes the state data defined at (1) to both the onCreate() method (2) and the onRestoreInstanceState() method (3).

Save Your Activity State

As your activity begins to stop, the system calls onSaveInstanceState() so your activity can save state information with a collection of key-value pairs. The default implementation of this method saves information about the state of the activity’s view hierarchy, such as the text in an EditText widget or the scroll position of a ListView .

To save additional state information for your activity, you must implement onSaveInstanceState() and add key-value pairs to the Bundle object. For example:

Caution: Always call the superclass implementation of onSaveInstanceState() so the default implementation can save the state of the view hierarchy.

Restore Your Activity State

When your activity is recreated after it was previously destroyed, you can recover your saved state from the Bundle that the system passes your activity. Both the onCreate() and onRestoreInstanceState() callback methods receive the same Bundle that contains the instance state information.

Because the onCreate() method is called whether the system is creating a new instance of your activity or recreating a previous one, you must check whether the state Bundle is null before you attempt to read it. If it is null, then the system is creating a new instance of the activity, instead of restoring a previous one that was destroyed.

For example, here’s how you can restore some state data in onCreate() :

Instead of restoring the state during onCreate() you may choose to implement onRestoreInstanceState() , which the system calls after the onStart() method. The system calls onRestoreInstanceState() only if there is a saved state to restore, so you do not need to check whether the Bundle is null:

Caution: Always call the superclass implementation of onRestoreInstanceState() so the default implementation can restore the state of the view hierarchy.

To learn more about recreating your activity due to a restart event at runtime (such as when the screen rotates), read Handling Runtime Changes.

Источник

Activity Recreating in android

In this blog,
I have talked about activity recreating in android. And will give the some facts related to save the Activity State.

There are a few scenarios in which your activity is destroyed due to normal app behavior, such as

• When the user presses the Back button or your activity signals its own destruction by calling finish().
• The system may also destroy your activity if it’s currently stopped and hasn’t been used in a long time.
• The foreground activity requires more resources so the system must shut down background processes to recover memory.

However, if the system destroys the activity due to system constraints, then although the actual Activity instance is gone,

The system remembers that it existed such that if the user navigates back to it, the system creates a new instance of the activity using a set of saved data that describes the state of the activity when it was destroyed. The saved data that the system uses to restore the previous state is called the “instance state” and is a collection of key-value pairs stored in a Bundle object.

Note: Your activity will be destroyed and recreated each time the user rotates the screen.

How to re-opening the activity

For recreating the activity, you can use the simple recreate() or startActivity(intent).

While using the recreate method works by doing,

Источник

Recreating an Activity

This lesson teaches you to

You should also read

There are a few scenarios in which your activity is destroyed due to normal app behavior, such as when the user presses the Back button or your activity signals its own destruction by calling finish() . The system may also destroy your activity if it’s currently stopped and hasn’t been used in a long time or the foreground activity requires more resources so the system must shut down background processes to recover memory.

When your activity is destroyed because the user presses Back or the activity finishes itself, the system’s concept of that Activity instance is gone forever because the behavior indicates the activity is no longer needed. However, if the system destroys the activity due to system constraints (rather than normal app behavior), then although the actual Activity instance is gone, the system remembers that it existed such that if the user navigates back to it, the system creates a new instance of the activity using a set of saved data that describes the state of the activity when it was destroyed. The saved data that the system uses to restore the previous state is called the «instance state» and is a collection of key-value pairs stored in a Bundle object.

Caution: Your activity will be destroyed and recreated each time the user rotates the screen. When the screen changes orientation, the system destroys and recreates the foreground activity because the screen configuration has changed and your activity might need to load alternative resources (such as the layout).

By default, the system uses the Bundle instance state to save information about each View object in your activity layout (such as the text value entered into an EditText object). So, if your activity instance is destroyed and recreated, the state of the layout is restored to its previous state with no code required by you. However, your activity might have more state information that you’d like to restore, such as member variables that track the user’s progress in the activity.

Note: In order for the Android system to restore the state of the views in your activity, each view must have a unique ID, supplied by the android:id attribute.

To save additional data about the activity state, you must override the onSaveInstanceState() callback method. The system calls this method when the user is leaving your activity and passes it the Bundle object that will be saved in the event that your activity is destroyed unexpectedly. If the system must recreate the activity instance later, it passes the same Bundle object to both the onRestoreInstanceState() and onCreate() methods.

Figure 2. As the system begins to stop your activity, it calls onSaveInstanceState() (1) so you can specify additional state data you’d like to save in case the Activity instance must be recreated. If the activity is destroyed and the same instance must be recreated, the system passes the state data defined at (1) to both the onCreate() method (2) and the onRestoreInstanceState() method (3).

Save Your Activity State

As your activity begins to stop, the system calls onSaveInstanceState() so your activity can save state information with a collection of key-value pairs. The default implementation of this method saves information about the state of the activity’s view hierarchy, such as the text in an EditText widget or the scroll position of a ListView .

To save additional state information for your activity, you must implement onSaveInstanceState() and add key-value pairs to the Bundle object. For example:

Caution: Always call the superclass implementation of onSaveInstanceState() so the default implementation can save the state of the view hierarchy.

Restore Your Activity State

When your activity is recreated after it was previously destroyed, you can recover your saved state from the Bundle that the system passes your activity. Both the onCreate() and onRestoreInstanceState() callback methods receive the same Bundle that contains the instance state information.

Because the onCreate() method is called whether the system is creating a new instance of your activity or recreating a previous one, you must check whether the state Bundle is null before you attempt to read it. If it is null, then the system is creating a new instance of the activity, instead of restoring a previous one that was destroyed.

For example, here’s how you can restore some state data in onCreate() :

Instead of restoring the state during onCreate() you may choose to implement onRestoreInstanceState() , which the system calls after the onStart() method. The system calls onRestoreInstanceState() only if there is a saved state to restore, so you do not need to check whether the Bundle is null:

Caution: Always call the superclass implementation of onRestoreInstanceState() so the default implementation can restore the state of the view hierarchy.

To learn more about recreating your activity due to a restart event at runtime (such as when the screen rotates), read Handling Runtime Changes.

Источник

Перезагрузить активность в Android

это хорошая практика, чтобы перезагрузить Activity на Android?

что было бы лучшим способом сделать это? this.finish а то this.startActivity активность Intent ?

14 ответов

Вы можете просто использовать

обновление Activity изнутри.

это то, что я делаю, чтобы перезагрузить действие после изменения возврата из изменения предпочтений.

это по существу заставляет активность перерисовывать себя.

обновление: лучший способ сделать это-вызвать recreate() метод. Это приведет к воссозданию активности.

для тех, кто не хочет видеть, что мигает после recreate () метод просто использовать

Мне нужно было срочно обновить список сообщений в одном из моих приложений, поэтому я просто выполнил обновление моей основной активности пользовательского интерфейса, прежде чем закрыть диалоговое окно, в котором я был. Я уверен, что есть и лучшие способы добиться этого.

Android включает в себя систему управления процессами, которая обрабатывает создание и уничтожение деятельности, которая в значительной степени отрицает любую выгоду, которую вы увидите от ручного перезапуска деятельности. Вы можете посмотреть дополнительную информацию о нем по адресу Основы Применения

хорошая практика заключается в том, чтобы гарантировать, что ваши методы onPause и onStop освобождают любые ресурсы, которые вам не нужно удерживать и использовать onLowMemory уменьшить ваши потребности деятельностей до абсолютного минимума.

Источник

Starting Another Activity

This lesson teaches you to

You should also read

After completing the previous lesson, you have an app that shows an activity (a single screen) with a text field and a button. In this lesson, you’ll add some code to MainActivity that starts a new activity when the user clicks the Send button.

Respond to the Send Button

To respond to the button’s on-click event, open the activity_main.xml layout file and add the android:onClick attribute to the element:

The android:onClick attribute’s value, «sendMessage» , is the name of a method in your activity that the system calls when the user clicks the button.

Open the MainActivity class (located in the project’s src/ directory) and add the corresponding method:

This requires that you import the View class:

Tip: In Eclipse, press Ctrl + Shift + O to import missing classes (Cmd + Shift + O on Mac).

In order for the system to match this method to the method name given to android:onClick , the signature must be exactly as shown. Specifically, the method must:

• Be public
• Have a void return value
• Have a View as the only parameter (this will be the View that was clicked)

Next, you’ll fill in this method to read the contents of the text field and deliver that text to another activity.

Build an Intent

An Intent is an object that provides runtime binding between separate components (such as two activities). The Intent represents an app’s «intent to do something.» You can use intents for a wide variety of tasks, but most often they’re used to start another activity.

Inside the sendMessage() method, create an Intent to start an activity called DisplayMessageActivity :

The constructor used here takes two parameters:

• A Context as its first parameter ( this is used because the Activity class is a subclass of Context )
• The Class of the app component to which the system should deliver the Intent (in this case, the activity that should be started)

Sending an intent to other apps

The intent created in this lesson is what’s considered an explicit intent, because the Intent specifies the exact app component to which the intent should be given. However, intents can also be implicit, in which case the Intent does not specify the desired component, but allows any app installed on the device to respond to the intent as long as it satisfies the meta-data specifications for the action that’s specified in various Intent parameters. For more information, see the class about Interacting with Other Apps.

Note: The reference to DisplayMessageActivity will raise an error if you’re using an IDE such as Eclipse because the class doesn’t exist yet. Ignore the error for now; you’ll create the class soon.

An intent not only allows you to start another activity, but it can carry a bundle of data to the activity as well. Inside the sendMessage() method, use findViewById() to get the EditText element and add its text value to the intent:

Note: You now need import statements for android.content.Intent and android.widget.EditText . You’ll define the EXTRA_MESSAGE constant in a moment.

An Intent can carry a collection of various data types as key-value pairs called extras. The putExtra() method takes the key name in the first parameter and the value in the second parameter.

In order for the next activity to query the extra data, you should define the key for your intent’s extra using a public constant. So add the EXTRA_MESSAGE definition to the top of the MainActivity class:

It’s generally a good practice to define keys for intent extras using your app’s package name as a prefix. This ensures they are unique, in case your app interacts with other apps.

Start the Second Activity

To start an activity, call startActivity() and pass it your Intent . The system receives this call and starts an instance of the Activity specified by the Intent .

With this new code, the complete sendMessage() method that’s invoked by the Send button now looks like this:

Now you need to create the DisplayMessageActivity class in order for this to work.

Create the Second Activity

Figure 1. The new activity wizard in Eclipse.

To create a new activity using Eclipse:

1. Click Newin the toolbar.
2. In the window that appears, open the Android folder and select Android Activity. Click Next.
3. Select BlankActivity and click Next.
4. Fill in the activity details:
   • Project: MyFirstApp
   • Activity Name: DisplayMessageActivity
   • Layout Name: activity_display_message
   • Title: My Message
   • Hierarchial Parent: com.example.myfirstapp.MainActivity
   • Navigation Type: None

Click Finish.

If you’re using a different IDE or the command line tools, create a new file named DisplayMessageActivity.java in the project’s src/ directory, next to the original MainActivity.java file.

Open the DisplayMessageActivity.java file. If you used Eclipse to create this activity:

• The class already includes an implementation of the required onCreate() method.
• There’s also an implementation of the onCreateOptionsMenu() method, but you won’t need it for this app so you can remove it.
• There’s also an implementation of onOptionsItemSelected() which handles the behavior for the action bar’s Up behavior. Keep this one the way it is.

Because the ActionBar APIs are available only on HONEYCOMB (API level 11) and higher, you must add a condition around the getActionBar() method to check the current platform version. Additionally, you must add the @SuppressLint(«NewApi») tag to the onCreate() method to avoid lint errors.

The DisplayMessageActivity class should now look like this:

If you used an IDE other than Eclipse, update your DisplayMessageActivity class with the above code.

All subclasses of Activity must implement the onCreate() method. The system calls this when creating a new instance of the activity. This method is where you must define the activity layout with the setContentView() method and is where you should perform initial setup for the activity components.

Note: If you are using an IDE other than Eclipse, your project does not contain the activity_display_message layout that’s requested by setContentView() . That’s OK because you will update this method later and won’t be using that layout.

Add the title string

If you used Eclipse, you can skip to the next section, because the template provides the title string for the new activity.

If you’re using an IDE other than Eclipse, add the new activity’s title to the strings.xml file:

Add it to the manifest

All activities must be declared in your manifest file, AndroidManifest.xml , using an element.

When you use the Eclipse tools to create the activity, it creates a default entry. If you’re using a different IDE, you need to add the manifest entry yourself. It should look like this:

The android:parentActivityName attribute declares the name of this activity’s parent activity within the app’s logical hierarchy. The system uses this value to implement default navigation behaviors, such as Up navigation on Android 4.1 (API level 16) and higher. You can provide the same navigation behaviors for older versions of Android by using the Support Library and adding the element as shown here.

Note: Your Android SDK should already include the latest Android Support Library. It’s included with the ADT Bundle but if you’re using a different IDE, you should have installed it during the Adding Platforms and Packages step. When using the templates in Eclipse, the Support Library is automatically added to your app project (you can see the library’s JAR file listed under Android Dependencies). If you’re not using Eclipse, you need to manually add the library to your project—follow the guide for setting up the Support Library then return here.

If you’re developing with Eclipse, you can run the app now, but not much happens. Clicking the Send button starts the second activity but it uses a default «Hello world» layout provided by the template. You’ll soon update the activity to instead display a custom text view, so if you’re using a different IDE, don’t worry that the app won’t yet compile.

Receive the Intent

Every Activity is invoked by an Intent , regardless of how the user navigated there. You can get the Intent that started your activity by calling getIntent() and retrieve the data contained within it.

In the DisplayMessageActivity class’s onCreate() method, get the intent and extract the message delivered by MainActivity :

Display the Message

To show the message on the screen, create a TextView widget and set the text using setText() . Then add the TextView as the root view of the activity’s layout by passing it to setContentView() .

The complete onCreate() method for DisplayMessageActivity now looks like this:

You can now run the app. When it opens, type a message in the text field, click Send, and the message appears on the second activity.

Figure 2. Both activities in the final app, running on Android 4.0.

That’s it, you’ve built your first Android app!

To learn more about building Android apps, continue to follow the basic training classes. The next class is Managing the Activity Lifecycle.

Источник