android définition - Comment démarrer une nouvelle activité en cliquant sur le bouton





données créer (16)


Démarrer une activité à partir d'une autre activité est un scénario très courant parmi les applications android.
Pour démarrer une activité, vous avez besoin d'un objet [Intent][1] .

Comment créer des objets Intent?

Un objet d'intention prend deux paramètres dans son constructeur

  1. Le contexte
  2. Nom de l'activité à démarrer.

Exemple:

Par exemple, si vous avez deux activités, dites HomeActivity et DetailActivity et vous voulez démarrer DetailActivity partir de HomeActivity (HomeActivity -> DetailActivity).

Voici l'extrait de code qui montre comment démarrer DetailActivity depuis

HomeActivité.

Intent i = new Intent(HomeActivity.this,DetailActivity.class);
startActivity(i);

Et vous avez terminé.

Revenons à la partie clic sur le bouton.

Button button = (Button) findViewById(R.id.someid);

button.setOnClickListener(new View.OnClickListener() {

     @Override
     public void onClick(View view) {
         Intent i = new Intent(HomeActivity.this,DetailActivity.class);
         startActivity(i);  
      }

});

Dans une application Android, comment démarrer une nouvelle activité (GUI) lorsqu'un utilisateur clique sur un bouton dans une autre activité, et comment transmettre des données entre ces deux activités?




À partir de l'activité d'envoi, essayez le code suivant

   //EXTRA_MESSAGE is our key and it's value is 'packagename.MESSAGE'
    public static final String EXTRA_MESSAGE = "packageName.MESSAGE";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
       ....

        //Here we declare our send button
        Button sendButton = (Button) findViewById(R.id.send_button);
        sendButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //declare our intent object which takes two parameters, the context and the new activity name

                // the name of the receiving activity is declared in the Intent Constructor
                Intent intent = new Intent(getApplicationContext(), NameOfReceivingActivity.class);

                String sendMessage = "hello world"
                //put the text inside the intent and send it to another Activity
                intent.putExtra(EXTRA_MESSAGE, sendMessage);
                //start the activity
                startActivity(intent);

            }

À partir de l'activité de réception, essayez le code suivant:

   protected void onCreate(Bundle savedInstanceState) {
 //use the getIntent()method to receive the data from another activity
 Intent intent = getIntent();

//extract the string, with the getStringExtra method
String message = intent.getStringExtra(NewActivityName.EXTRA_MESSAGE);

Ensuite, ajoutez simplement le code suivant au fichier AndroidManifest.xml

  android:name="packagename.NameOfTheReceivingActivity"
  android:label="Title of the Activity"
  android:parentActivityName="packagename.NameOfSendingActivity"



Prenez d'abord Button en XML.

  <Button
        android:id="@+id/pre"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="@mipmap/ic_launcher"
        android:text="Your Text"
        />

Faire l'écouteur du bouton.

 pre.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Intent intent = new Intent(MainActivity.this, SecondActivity.class);
            startActivity(intent);
        }
    });



Implémentez l'interface View.OnClickListener et remplacez la méthode onClick.

ImageView btnSearch;

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_search1);
        ImageView btnSearch = (ImageView) findViewById(R.id.btnSearch);
        btnSearch.setOnClickListener(this);
    }

@Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btnSearch: {
                Intent intent = new Intent(Search.this,SearchFeedActivity.class);
                startActivity(intent);
                break;
            }



Intent i = new Intent(firstactivity.this, secondactivity.class);
startActivity(i);



    Intent in = new Intent(getApplicationContext(),SecondaryScreen.class);    
    startActivity(in);

    This is an explicit intent to start secondscreen activity.



Les réponses actuelles sont bonnes, mais une réponse plus complète est nécessaire pour les débutants. Il existe 3 façons différentes de démarrer une nouvelle activité dans Android, et tous utilisent la classe Intent ; Intention Développeurs Android .

  1. Utilisation de l'attribut onClick du bouton. (Débutant)
  2. Affectation d'un OnClickListener() via une classe anonyme. (Intermédiaire)
  3. Méthode d'interface large d'activité utilisant l'instruction switch . (Pro)

Voici le lien vers mon exemple si vous voulez suivre: https://github.com/martinsing/ToNewActivityButtons

1. Utilisation de l'attribut onClick du bouton. (Débutant)

Les boutons ont un attribut onClick qui se trouve dans le fichier .xml:

<Button
    android:id="@+id/button1"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="goToAnActivity"
    android:text="to an activity" />

<Button
    android:id="@+id/button2"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:onClick="goToAnotherActivity"
    android:text="to another activity" />

En cours de Java:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_activity);
}

public void goToAnActivity(View view) {
    Intent Intent = new Intent(this, AnActivity.class);
    startActivity(Intent);
}

public void goToAnotherActivity(View view) {
    Intent Intent = new Intent(this, AnotherActivity.class);
    startActivity(Intent);
}

Avantage: Facile à réaliser à la volée, modulaire, et pouvant facilement régler plusieurs onClicks dans le même but facilement.

Inconvénient: lisibilité difficile lors de l'examen.

2. Affectation d'un OnClickListener() via une classe anonyme. (Intermédiaire)

C'est lorsque vous définissez un setOnClickListener() distinct à chaque button et remplacez chaque onClick() avec sa propre intention.

En cours de Java:

@Override
protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_activity);

        button1 = (Button) findViewById(R.id.button1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent Intent = new Intent(view.getContext(), AnActivity.class);
                view.getContext().startActivity(Intent);}
            });

        button2 = (Button) findViewById(R.id.button2);
        button2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent Intent = new Intent(view.getContext(), AnotherActivity.class);
                view.getContext().startActivity(Intent);}
            });

Avantage: Facile à fabriquer à la volée.

Inconvénient: il y aura beaucoup de classes anonymes qui rendront la lisibilité difficile lors de l'examen.

3. Méthode d'interface large d'activité utilisant l'instruction switch . (Pro)

C'est lorsque vous utilisez une instruction switch pour vos boutons dans la méthode onClick() pour gérer tous les boutons de l'activité.

En cours de Java:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main_activity);

    button1 = (Button) findViewById(R.id.button1);
    button2 = (Button) findViewById(R.id.button2);
    button1.setOnClickListener(this);
    button2.setOnClickListener(this);
}

@Override
public void onClick(View view) {
    switch (view.getId()){
        case R.id.button1:
            Intent intent1 = new Intent(this, AnActivity.class);
            startActivity(intent1);
            break;
        case R.id.button2:
            Intent intent2 = new Intent(this, AnotherActivity.class);
            startActivity(intent2);
            break;
        default:
            break;
    }

Avantage: Gestion facile des boutons car toutes les intentions de bouton sont enregistrées dans une seule méthode onClick()

Pour la deuxième partie de la question, le passage des données, s'il vous plaît voir Comment puis-je transmettre des données entre les activités dans l'application Android?




Bien que des réponses appropriées aient déjà été fournies mais je suis ici pour chercher la réponse dans la langue Kotlin. Cette question ne concerne pas la langue spécifique, donc j'ajoute le code pour accomplir cette tâche en langage Kotlin.

Voici comment vous faites cela à Kotlin pour andorid

testActivityBtn1.setOnClickListener{
      val intent = Intent(applicationContext,MainActivity::class.java)
      startActivity(intent)

 }



La façon de démarrer de nouvelles activités consiste à diffuser une intention, et il existe un type spécifique d'intention que vous pouvez utiliser pour transmettre des données d'une activité à une autre. Ma recommandation est que vous consultez les docs de développeur Android liés aux intents ; c'est une mine d'informations sur le sujet, et a des exemples aussi.




Créez une intention pour une activité ViewPerson et transmettez le PersonID (pour une recherche de base de données, par exemple).

Intent i = new Intent(getBaseContext(), ViewPerson.class);                      
i.putExtra("PersonID", personID);
startActivity(i);

Ensuite, dans ViewPerson Activity, vous pouvez obtenir le paquet de données supplémentaires, assurez-vous qu'il n'est pas nul (dans le cas où vous ne transmettez pas parfois de données), puis récupérez les données.

Bundle extras = getIntent().getExtras();
if(extras !=null)
{
     personID = extras.getString("PersonID");
}

Maintenant, si vous avez besoin de partager des données entre deux activités, vous pouvez également avoir un singleton global.

public class YourApplication extends Application 
{     
     public SomeDataClass data = new SomeDataClass();
}

Puis appelez-le dans n'importe quelle activité en:

YourApplication appState = ((YourApplication)this.getApplication());
appState.data.CallSomeFunctionHere(); // Do whatever you need to with data here.  Could be setter/getter or some other type of logic



Intent iinent= new Intent(Homeactivity.this,secondactivity.class);
startActivity(iinent);



Facile.

Intent myIntent = new Intent(CurrentActivity.this, NextActivity.class);
myIntent.putExtra("key", value); //Optional parameters
CurrentActivity.this.startActivity(myIntent);

Les extras sont récupérés de l'autre côté via:

@Override
protected void onCreate(Bundle savedInstanceState) {
    Intent intent = getIntent();
    String value = intent.getStringExtra("key"); //if it's a string you stored.
}

N'oubliez pas d'ajouter votre nouvelle activité dans le fichier AndroidManifest.xml:

<activity android:label="@string/app_name" android:name="NextActivity"/>



Emmanuel,

Je pense que les informations supplémentaires doivent être mises avant le démarrage de l'activité, sinon les données ne seront pas encore disponibles si vous y accédez dans la méthode onCreate de NextActivity.

Intent myIntent = new Intent(CurrentActivity.this, NextActivity.class);

myIntent.putExtra("key", value);

CurrentActivity.this.startActivity(myIntent);



Commencez une autre activité de cette activité et vous pouvez également passer des paramètres via Bundle Object.

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);

Récupérer des données dans une autre activité (YourActivity)

String s = getIntent().getStringExtra("USER_NAME");



Essayez cette méthode simple.

startActivity(new Intent(MainActivity.this, SecondActivity.class));



Même si ce n'est pas "la manière Android", j'ai obtenu de très bons résultats en manipulant les changements d'orientation moi-même et en repositionnant simplement les widgets dans une vue pour prendre en compte l'orientation modifiée. C'est plus rapide que toute autre approche, car vos vues ne doivent pas être sauvegardées et restaurées. Il fournit également une expérience plus transparente à l'utilisateur, car les widgets repositionnés sont exactement les mêmes widgets, juste déplacés et / ou redimensionnés. Non seulement l'état du modèle, mais aussi l'état d'affichage, peuvent être préservés de cette manière.

RelativeLayout peut parfois être un bon choix pour une vue qui doit se réorienter de temps en temps. Vous fournissez simplement un ensemble de paramètres de mise en page du portrait et un ensemble de paramètres de mise en page paysagés, avec des règles de positionnement relatives différentes pour chaque widget enfant. Ensuite, dans votre méthode onConfigurationChanged() , vous passez la méthode appropriée à un appel setLayoutParams() sur chaque enfant. Si un contrôle enfant lui-même doit être réorienté en interne , vous appelez simplement une méthode sur cet enfant pour effectuer la réorientation. Cet enfant appelle également des méthodes sur l'un de ses contrôles enfants qui nécessitent une réorientation interne, et ainsi de suite.





android android-intent android-activity android-button android-lifecycle