Android
Intento

introduzione

Sintassi

• Intento intenzionale ()
• Intento intenzionale (intento intenzionale)
• Intento intento (azione String)
• Intent Intent (String action, Uri uri)
• Intento Intento (Context packageContext, Class <?> Cls)
• Intent Intent (String action, Uri uri, Context packageContext, Class <?> Cls)
• void startActivity (intento intenzionale)
• void startActivity (intent intent, opzioni bundle)
• void startActivityForResult (Intent intention, int requestCode)
• void startActivityForResult (Intent intent, int requestCode, Opzioni bundle)
• Intent putExtra (nome stringa, valore doppio [])
• Intent putExtra (nome stringa, valore int)
• Intent putExtra (nome stringa, valore CharSequence)
• Intent putExtra (nome stringa, valore char)
• Intent putExtra (nome stringa, valore bundle)
• Intent putExtra (nome stringa, valore Parcelable [])
• Intent putExtra (nome stringa, valore serializzabile)
• Intent putExtra (nome stringa, valore int [])
• Intent putExtra (nome stringa, valore float)
• Intent putExtra (nome stringa, valore byte [])
• Intent putExtra (nome stringa, valore [] lungo)
• Intent putExtra (Nome stringa, valore Parcelable)
• Intent putExtra (nome stringa, valore float [])
• Intent putExtra (nome stringa, valore lungo)
• Intent putExtra (nome stringa, valore String [])
• Intent putExtra (nome stringa, valore booleano)
• Intent putExtra (nome stringa, valore booleano [])
• Intent putExtra (String name, short value)
• Intent putExtra (String name, double value)
• Intent putExtra (nome stringa, valore [] breve)
• Intent putExtra (nome stringa, valore stringa)
• Intent putExtra (nome stringa, valore byte)
• Intent putExtra (nome stringa, valore char [])
• Intent putExtra (nome stringa, valore CharSequence [])

Parametri

Osservazioni

PackageManager pm = getActivity().getPackageManager();
if (intent.resolveActivity(pm) != null) {
    //intent can be handled
    startActivity(intent);
} else {
     //intent can not be handled
}

Inizia un'attività

Questo esempio avvierà DestinationActivity da OriginActivity .

Qui, il costruttore Intent prende due parametri:

1. Un contesto come primo parametro (questo viene utilizzato perché la classe Attività è una sottoclasse di Context)
2. La classe del componente dell'app a cui il sistema deve fornire l'intento (in questo caso, l'attività che deve essere avviata)

public class OriginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);

        Intent intent = new Intent(this, DestinationActivity.class);
        
        startActivity(intent);
        finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity again.
    }
}

Un altro modo per creare l' Intent di aprire DestinationActivity consiste nell'usare il costruttore predefinito per l' Intent e utilizzare il metodo setClass() per dirgli quale attività aprire:

Intent i=new Intent();
i.setClass(this, DestinationActivity.class);
startActivity(intent);
finish(); // Optionally, you can close OriginActivity. In this way when the user press back from DestinationActivity he/she won't land on OriginActivity 

Trasmissione dei dati tra le attività

Questo esempio illustra l'invio di una String con valore come "Some data!" da OriginActivity a DestinationActivity .

NOTA: questo è il modo più semplice per inviare dati tra due attività. Vedere l'esempio sull'uso del pattern di partenza per un'implementazione più robusta.

OriginActivity

public class OriginActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_origin);
        
        // Create a new Intent object, containing DestinationActivity as target Activity.
        final Intent intent = new Intent(this, DestinationActivity.class);

        // Add data in the form of key/value pairs to the intent object by using putExtra()
        intent.putExtra(DestinationActivity.EXTRA_DATA, "Some data!");

        // Start the target Activity with the intent object
        startActivity(intent);
    }
} 

DestinationActivity

public class DestinationActivity extends AppCompatActivity {

    public static final String EXTRA_DATA = "EXTRA_DATA";

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

        // getIntent() returns the Intent object which was used to start this Activity
        final Intent intent = getIntent();

        // Retrieve the data from the intent object by using the same key that
        // was previously used to add data to the intent object in OriginActivity.
        final String data = intent.getStringExtra(EXTRA_DATA);
    }
}

È anche possibile passare altri tipi di dati primitive oltre a arrays , dati Bundle e Parcelable . Passare Serializable è anche possibile, ma dovrebbe essere evitato in quanto è più di tre volte più lento di Parcelable .

Serializable è interface Java standard. Contrassegnare semplicemente una classe come Serializable implementando l' interface Serializable e Java la serializzerà automaticamente durante le situazioni richieste.

Parcelable è una specifica Android interface che può essere implementato su tipi di dati personalizzati (vale a dire i propri oggetti / oggetti POJO), consente l'oggetto sia appiattito e si ricostruiscono, senza la destinazione bisogno di fare nulla. C'è un esempio di documentazione per rendere un oggetto parcellizzabile .

Una volta che hai un oggetto parcelable puoi inviarlo come un tipo primitivo, con un oggetto intent:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

O in un pacchetto / come argomento per un frammento:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

e poi anche leggerlo dall'intenzione della destinazione usando getParcelableExtra:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

O quando si legge in un frammento di un pacchetto:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

Una volta che hai un oggetto Serializable puoi metterlo in un oggetto intent:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

e quindi anche leggerlo dall'oggetto intent alla destinazione come mostrato di seguito:

final SerializableType data = (SerializableType)bundle.getSerializable(EXTRA_DATA); 

Inviando email

// Compile a Uri with the 'mailto' schema
Intent emailIntent = new Intent(Intent.ACTION_SENDTO, Uri.fromParts(
        "mailto","[email protected]", null));
// Subject
emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Hello World!");
// Body of email
emailIntent.putExtra(Intent.EXTRA_TEXT, "Hi! I am sending you a test email.");
// File attachment
emailIntent.putExtra(Intent.EXTRA_STREAM, attachedFileUri);

// Check if the device has an email client
if (emailIntent.resolveActivity(getPackageManager()) != null) {
     // Prompt the user to select a mail app
     startActivity(Intent.createChooser(emailIntent,"Choose your mail application"));
} else {
    // Inform the user that no email clients are installed or provide an alternative
}

Questo pre-riempirà un'e-mail in un'app di posta elettronica a scelta dell'utente.

Se è necessario aggiungere un allegato, è possibile utilizzare Intent.ACTION_SEND anziché Intent.ACTION_SENDTO . Per più allegati puoi utilizzare ACTION_SEND_MULTIPLE

Una parola di cautela: non tutti i dispositivi dispongono di un provider per ACTION_SENDTO e la chiamata startActivity() senza verificare con resolveActivity() prima potrebbe lanciare resolveActivity() ActivityNotFoundException.

Ottenere un risultato da un'altra attività

Utilizzando startActivityForResult(Intent intent, int requestCode) è possibile avviare un'altra Activity e quindi ricevere un risultato da tale Activity nel onActivityResult(int requestCode, int resultCode, Intent data) . Il risultato sarà restituito come Intent . Un intento può contenere dati tramite un pacchetto

In questo esempio, MainActivity avvierà un'attività DetailActivity e quindi si aspetta un risultato da essa. Ogni tipo di richiesta deve avere il proprio int codice di richiesta, in modo che nel sovrascritto onActivityResult(int requestCode, int resultCode, Intent data) metodo MainActivity , può essere determinato che chiedono di elaborare confrontando valori di requestCode e REQUEST_CODE_EXAMPLE (anche se in questo esempio, ce n'è solo uno).

Attività principale:

public class MainActivity extends Activity {

    // Use a unique request code for each use case 
    private static final int REQUEST_CODE_EXAMPLE = 0x9345; 

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

        // Create a new instance of Intent to start DetailActivity
        final Intent intent = new Intent(this, DetailActivity.class);

        // Start DetailActivity with the request code
        startActivityForResult(intent, REQUEST_CODE_EXAMPLE);
    }

    // onActivityResult only get called 
    // when the other Activity previously started using startActivityForResult
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // First we need to check if the requestCode matches the one we used.
        if(requestCode == REQUEST_CODE_EXAMPLE) {

            // The resultCode is set by the DetailActivity
            // By convention RESULT_OK means that whatever
            // DetailActivity did was executed successfully
            if(resultCode == Activity.RESULT_OK) {
                // Get the result from the returned Intent
                final String result = data.getStringExtra(DetailActivity.EXTRA_DATA);

                // Use the data - in this case, display it in a Toast.
                Toast.makeText(this, "Result: " + result, Toast.LENGTH_LONG).show();
            } else {
                // setResult wasn't successfully executed by DetailActivity 
                // Due to some error or flow of control. No data to retrieve.
            }
        }
    }
}

DetailActivity:

public class DetailActivity extends Activity {

    // Constant used to identify data sent between Activities.
    public static final String EXTRA_DATA = "EXTRA_DATA";

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

        final Button button = (Button) findViewById(R.id.button);
        // When this button is clicked we want to return a result
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // Create a new Intent object as container for the result
                final Intent data = new Intent();

                // Add the required data to be returned to the MainActivity
                data.putExtra(EXTRA_DATA, "Some interesting data!");
                
                // Set the resultCode as Activity.RESULT_OK to 
                // indicate a success and attach the Intent
                // which contains our result data
                setResult(Activity.RESULT_OK, data); 

                // With finish() we close the DetailActivity to 
                // return back to MainActivity
                finish();
            }
        });
    }

    @Override
    public void onBackPressed() {
        // When the user hits the back button set the resultCode 
        // as Activity.RESULT_CANCELED to indicate a failure
        setResult(Activity.RESULT_CANCELED);
        super.onBackPressed();
    }
}

Alcune cose che devi sapere:

• I dati vengono restituiti solo dopo aver chiamato finish() . Devi chiamare setResult() prima di chiamare finish() , altrimenti non verrà restituito alcun risultato.

• Assicurati che la tua Activity non stia utilizzando android:launchMode="singleTask" , altrimenti l' Activity verrà eseguita in un'attività separata e pertanto non riceverai un risultato da essa. Se la tua Activity utilizza singleTask come modalità di avvio, chiamerà onActivityResult() immediatamente con un codice risultato di Activity.RESULT_CANCELED .

• android:launchMode="singleInstance" attenzione quando usi android:launchMode="singleInstance" . Sui dispositivi prima di Lollipop (Android 5.0, Livello API 21), le attività non restituiscono un risultato.

• È possibile utilizzare intenti espliciti o impliciti quando si chiama startActivityForResult() . Quando si avvia una delle proprie attività per ricevere un risultato, è necessario utilizzare un intento esplicito per assicurarsi di ricevere il risultato previsto. Un intent esplicito viene sempre consegnato al suo obiettivo, indipendentemente da cosa contenga; il filter non viene consultato. Ma un intento implicito viene consegnato a un componente solo se può passare attraverso uno dei filtri del componente.

Apri un URL in un browser

Apertura con il browser predefinito

Questo esempio mostra come è possibile aprire un URL a livello di programmazione nel browser Web incorporato anziché all'interno dell'applicazione. Ciò consente all'app di aprire una pagina Web senza la necessità di includere l'autorizzazione INTERNET nel file manifest.

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Uri uri = Uri.parse(url);
    Intent intent = new Intent(Intent.ACTION_VIEW, uri);
    // Verify that the intent will resolve to an activity
    if (intent.resolveActivity(getPackageManager()) != null) {
        // Here we use an intent without a Chooser unlike the next example
        startActivity(intent);
    } 
}

Chiedere all'utente di selezionare un browser

Nota che questo esempio usa il metodo Intent.createChooser() :

public void onBrowseClick(View v) {
    String url = "http://www.google.com";
    Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
    // Note the Chooser below. If no applications match, 
    // Android displays a system message.So here there is no need for try-catch.
    startActivity(Intent.createChooser(intent, "Browse with"));
   
}

In alcuni casi, l'URL può iniziare con "www" . In questo caso otterrai questa eccezione:

android.content.ActivityNotFoundException : Nessuna attività trovata per gestire Intento

L'URL deve sempre iniziare con "http: //" o "https: //" . Il tuo codice dovrebbe quindi controllarlo, come mostrato nel seguente frammento di codice:

if (!url.startsWith("https://") && !url.startsWith("http://")){
    url = "http://" + url;
}
Intent openUrlIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
if (openUrlIntent.resolveActivity(getPackageManager()) != null) {
    startActivity(openUrlIntent);
} 

Migliori pratiche

Controlla se sul dispositivo non ci sono app che possono ricevere l'intento implicito. In caso contrario, la tua app si bloccherà quando chiama startActivity() . Per prima verificare che esista un'app per ricevere l'intento, chiama resolveActivity() sull'oggetto Intent. Se il risultato non è nullo, c'è almeno un'app in grado di gestire l'intento ed è sicuro chiamare startActivity() . Se il risultato è nullo, non si dovrebbe usare l'intento e, se possibile, si dovrebbe disabilitare la funzione che richiama l'intento.

Cancellare una pila di attività

A volte potresti voler iniziare una nuova attività rimuovendo le attività precedenti dallo stack posteriore, quindi il pulsante Indietro non ti riporta indietro. Un esempio potrebbe essere l'avvio di un'app sull'attività di accesso, che ti porterà all'attività principale della tua applicazione, ma alla disconnessione vuoi essere reindirizzato al login senza la possibilità di tornare indietro. In un caso del genere puoi impostare il flag FLAG_ACTIVITY_CLEAR_TOP per l'intento, ovvero se l'attività avviata è già in esecuzione nell'attività corrente (LoginActivity), quindi anziché avviare una nuova istanza di tale attività, tutte le altre attività in alto di esso sarà chiuso e questo Intento sarà consegnato alla vecchia attività (ora in cima) come un nuovo Intento.

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

È inoltre possibile utilizzare le flag FLAG_ACTIVITY_NEW_TASK insieme a FLAG_ACTIVITY_CLEAR_TASK se si desidera cancellare tutte le attività nel back stack:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
// Closing all the Activities, clear the back stack.
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
startActivity(intent);

URI intenzionale

Questo esempio mostra come avviare l'intenzione dal browser:

<a href="intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end">Start intent</a>

Questo intento avvierà l'app con il pacchetto com.sample.test o aprirà google play con questo pacchetto.

Anche questo intento può essere avviato con javascript:

var intent = "intent://host.com/path#Intent;package=com.sample.test;scheme=yourscheme;end";
window.location.replace(intent)

Nell'attività questo host e percorso possono essere ottenuti dai dati di intenti:

@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    Uri data = getIntent().getData(); // returns host.com/path
}

Sintassi URI Intent:

HOST/URI-path // Optional host
#Intent;
    package=[string];
    action=[string];
    category=[string];
    component=[string];
    scheme=[string];
end;

Trasmissione di messaggi ad altri componenti

Gli intenti possono essere utilizzati per trasmettere messaggi ad altri componenti della tua applicazione (come un servizio in background in esecuzione) o all'intero sistema Android.

Per inviare una trasmissione all'interno dell'applicazione , utilizzare la classe LocalBroadcastManager :

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

LocalBroadcastManager manager = LocalBroadcastManager.getInstance(context);
manager.sendBroadcast(intent);

Per inviare una trasmissione a componenti esterni all'applicazione, utilizzare il metodo sendBroadcast() su un oggetto Context .

Intent intent = new Intent("com.example.YOUR_ACTION"); // the intent action
intent.putExtra("key", "value"); // data to be passed with your broadcast

context.sendBroadcast(intent);

Informazioni sulla ricezione di trasmissioni possono essere trovate qui: Broadcast Receiver

CustomTabsIntent per le schede personalizzate di Chrome

String url = "https://www.google.pl/";
CustomTabsIntent intent = new CustomTabsIntent.Builder()
                    .setStartAnimations(getContext(), R.anim.slide_in_right, R.anim.slide_out_left)
                    .setExitAnimations(getContext(), android.R.anim.slide_in_left, android.R.anim.slide_out_right)
                    .setCloseButtonIcon(BitmapFactory.decodeResource(getResources(), R.drawable.ic_arrow_back_white_24dp))
                    .setToolbarColor(Color.parseColor("#43A047"))
                    .enableUrlBarHiding()
                    .build();
            intent.launchUrl(getActivity(), Uri.parse(url));

compile 'com.android.support:customtabs:24.1.1'

Condivisione di più file tramite Intent

L'elenco delle stringhe passato come parametro al metodo share() contiene i percorsi di tutti i file che si desidera condividere.

In pratica, scorre i percorsi, li aggiunge a Uri e avvia l'attività che può accettare file di questo tipo.

  public static void share(AppCompatActivity context,List<String> paths) {

        if (paths == null || paths.size() == 0) {
            return;
        }
        ArrayList<Uri> uris = new ArrayList<>();
        Intent intent = new Intent();
        intent.setAction(android.content.Intent.ACTION_SEND_MULTIPLE);
        intent.setType("*/*");
        for (String path : paths) {
                File file = new File(path);
                uris.add(Uri.fromFile(file));
        }
        intent.putParcelableArrayListExtra(Intent.EXTRA_STREAM, uris);
        context.startActivity(intent);
    }

Motivo di partenza

Questo modello è un approccio più rigoroso per avviare un Activity . Il suo scopo è migliorare la leggibilità del codice, riducendo allo stesso tempo la complessità del codice, i costi di manutenzione e l'accoppiamento dei componenti.

L'esempio seguente implementa il pattern di partenza, che di solito viene implementato come metodo statico Activity stessa. Questo metodo statico accetta tutti i parametri richiesti, costruisce un Intent valido da quei dati e quindi avvia l' Activity .

Un Intent è un oggetto che fornisce il runtime vincolante tra componenti separati, come due attività. L'intento rappresenta "l'intenzione di fare qualcosa" di un'app. Puoi usare gli intent per una vasta gamma di attività, ma qui, il tuo intento inizia un'altra attività.

public class ExampleActivity extends AppCompatActivity {

    private static final String EXTRA_DATA = "EXTRA_DATA";

    public static void start(Context context, String data) {
        Intent intent = new Intent(context, ExampleActivity.class);
        intent.putExtra(EXTRA_DATA, data);
        context.startActivity(intent);
    }       

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

        Intent intent = getIntent();
        if(!intent.getExtras().containsKey(EXTRA_DATA)){
            throw new UnsupportedOperationException("Activity should be started using the static start method");
        }
        String data = intent.getStringExtra(EXTRA_DATA);
    }
}

Questo modello consente inoltre di forzare la trasmissione di ulteriori dati con l'intento.

L' ExampleActivity può quindi essere avviato in questo modo, dove context è un contesto di attività:

ExampleActivity.start(context, "Some data!");

Avvia il servizio non associato utilizzando un intent

Un servizio è un componente che viene eseguito in background (sul thread dell'interfaccia utente) senza interazione diretta con l'utente. Un servizio non associato è appena iniziato e non è legato al ciclo di vita di alcuna attività.

Per avviare un Servizio puoi fare come mostrato nell'esempio qui sotto:

// This Intent will be used to start the service
Intent i= new Intent(context, ServiceName.class);
// potentially add data to the intent extras
i.putExtra("KEY1", "Value to be used by the service");
context.startService(i);

Puoi utilizzare qualsiasi extra dall'intento utilizzando una onStartCommand() :

public class MyService extends Service {
    public MyService() {
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        if (intent != null) {
            Bundle extras = intent.getExtras();
            String key1 = extras.getString("KEY1", "");
            if (key1.equals("Value to be used by the service")) {
                //do something
            }
        }
        return START_STICKY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

Condividi l'intento

Condividi semplici informazioni con diverse app.

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "This is my text to send.");
sendIntent.setType("text/plain");
startActivity(Intent.createChooser(sendIntent, getResources().getText(R.string.send_to)));

Condividi un'immagine con diverse app.

Intent shareIntent = new Intent();
shareIntent.setAction(Intent.ACTION_SEND);
shareIntent.putExtra(Intent.EXTRA_STREAM, uriToImage);
shareIntent.setType("image/jpeg");
startActivity(Intent.createChooser(shareIntent, getResources().getText(R.string.send_to)));

Avvia il dialer

Questo esempio mostra come aprire un dialer predefinito (un'app che effettua chiamate regolari) con un numero telefonico fornito già presente:

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:9988776655")); //Replace with valid phone number. Remember to add the tel: prefix, otherwise it will crash.
startActivity(intent);

Risultato dall'esecuzione del codice qui sopra:

Apri Google map con latitudine, longitudine specificate

Puoi passare latitudine, longitudine dalla tua app a Google map usando Intent

String uri = String.format(Locale.ENGLISH, "http://maps.google.com/maps?q=loc:%f,%f", 28.43242324,77.8977673);
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri));
startActivity(intent);

Trasmissione di dati diversi tramite Intent in Activity

1. Passare dati interi:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("intVariableName", intValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
int intValue = mIntent.getIntExtra("intVariableName", 0); // set 0 as the default value if no value for intVariableName found

2. Passando doppio dati:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("doubleVariableName", doubleValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
double doubleValue = mIntent.getDoubleExtra("doubleVariableName", 0.00); // set 0.00 as the default value if no value for doubleVariableName found

3. Passare dati stringa:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("stringVariableName", stringValue);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
String stringValue = mIntent.getExtras().getString("stringVariableName");

o

Intent mIntent = getIntent();
String stringValue = mIntent.getStringExtra("stringVariableName");

4. Passare i dati di ArrayList:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putStringArrayListExtra("arrayListVariableName", arrayList);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
arrayList = mIntent.getStringArrayListExtra("arrayListVariableName");

5. Passare dati oggetto:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("ObjectVariableName", yourObject);
startActivity(myIntent);

ReceiverActivity

Intent mIntent = getIntent();
yourObj = mIntent.getSerializableExtra("ObjectVariableName");

Nota: tenere presente che la classe personalizzata deve implementare l'interfaccia Serializable .

6. Passaggio di dati di HashMap <String, String>:

SenderActivity

HashMap <String, String> hashMap;

Intent mIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
mIntent.putExtra("hashMap", hashMap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();    
HashMap<String, String> hashMap = (HashMap<String, String>)
mIntent.getSerializableExtra("hashMap");

7. Passaggio dei dati bitmap:

SenderActivity

Intent myIntent = new Intent(SenderActivity.this, ReceiverActivity.class);
myIntent.putExtra("image",bitmap);
startActivity(mIntent);

ReceiverActivity

Intent mIntent = getIntent();
Bitmap bitmap = mIntent.getParcelableExtra("image");

Mostrare un File Chooser e leggere il risultato

Avvio di un'attività Selezione file

public void showFileChooser() {
    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);

    // Update with mime types
    intent.setType("*/*");

    // Update with additional mime types here using a String[]. 
    intent.putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes);

    // Only pick openable and local files. Theoretically we could pull files from google drive
    // or other applications that have networked files, but that's unnecessary for this example.
    intent.addCategory(Intent.CATEGORY_OPENABLE);
    intent.putExtra(Intent.EXTRA_LOCAL_ONLY, true);

    // REQUEST_CODE = <some-integer>
    startActivityForResult(intent, REQUEST_CODE);
}

Leggendo il risultato

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the user doesn't pick a file just return
    if (requestCode != REQUEST_CODE || resultCode != RESULT_OK) {
        return;
    }

    // Import the file
    importFile(data.getData());
}

public void importFile(Uri uri) {
    String fileName = getFileName(uri);

    // The temp file could be whatever you want
    File fileCopy = copyToTempFile(uri, File tempFile)

    // Done!
}

/**
 * Obtains the file name for a URI using content resolvers. Taken from the following link
 * https://developer.android.com/training/secure-file-sharing/retrieve-info.html#RetrieveFileInfo
 *
 * @param uri a uri to query
 * @return the file name with no path
 * @throws IllegalArgumentException if the query is null, empty, or the column doesn't exist
 */
private String getFileName(Uri uri) throws IllegalArgumentException {
    // Obtain a cursor with information regarding this uri
    Cursor cursor = getContentResolver().query(uri, null, null, null, null);

    if (cursor.getCount() <= 0) {
        cursor.close();
        throw new IllegalArgumentException("Can't obtain file name, cursor is empty");
    }

    cursor.moveToFirst();

    String fileName = cursor.getString(cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME));

    cursor.close();

    return fileName;
}

/**
 * Copies a uri reference to a temporary file
 *
 * @param uri      the uri used as the input stream
 * @param tempFile the file used as an output stream
 * @return the input tempFile for convenience
 * @throws IOException if an error occurs
 */
private File copyToTempFile(Uri uri, File tempFile) throws IOException {
    // Obtain an input stream from the uri
    InputStream inputStream = getContentResolver().openInputStream(uri);

    if (inputStream == null) {
        throw new IOException("Unable to obtain input stream from URI");
    }

    // Copy the stream to the temp file
    FileUtils.copyInputStreamToFile(inputStream, tempFile);

    return tempFile;
}

Passaggio dell'oggetto personalizzato tra le attività

È anche possibile passare il tuo oggetto personalizzato ad altre attività usando la classe Bundle .

Ci sono due modi:

• Interfaccia Serializable : per Java e Android
• Parcelable memoria interfaccia Parcelable , solo per Android (consigliato)

Parcelable

L'elaborazione parcelable è molto più veloce di serializzabile. Una delle ragioni di ciò è che siamo espliciti sul processo di serializzazione invece di usare la riflessione per dedurlo. È anche ovvio che il codice è stato fortemente ottimizzato per questo scopo.

public class MyObjects implements Parcelable {
    
    private int age;
    private String name;
    
    private ArrayList<String> address;
    
    public MyObjects(String name, int age, ArrayList<String> address) {
        this.name = name;
        this.age = age;
        this.address = address;
    
    }
    
    public MyObjects(Parcel source) {
        age = source.readInt();
        name = source.readString();
        address = source.createStringArrayList();
    }
    
    @Override
    public int describeContents() {
        return 0;
    }
    
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(age);
        dest.writeString(name);
        dest.writeStringList(address);
    }
    
    public int getAge() {
        return age;
    }
    
    public String getName() {
        return name;
    }
    
    public ArrayList<String> getAddress() {
        if (!(address == null))
            return address;
        else
            return new ArrayList<String>();
    }
    
    public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
        @Override
        public MyObjects[] newArray(int size) {
            return new MyObjects[size];
        }
    
        @Override
        public MyObjects createFromParcel(Parcel source) {
            return new MyObjects(source);
        }
    };
}

Invio del codice attività

MyObject mObject = new MyObject("name","age","Address array here");

//Passing MyOject 
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putExtra("UniqueKey", mObject);
startActivity(mIntent);

Ricevere l'oggetto nell'attività di destinazione.

//Getting MyObjects 
Intent mIntent = getIntent();
MyObjects workorder = (MyObjects) mIntent.getParcelable("UniqueKey");

Puoi passare l'oggetto Arrayylist di Parceble come sotto

//Array of MyObjects
ArrayList<MyObject> mUsers;

//Passing MyObject List
Intent mIntent = new Intent(FromActivity.this, ToActivity.class);
mIntent.putParcelableArrayListExtra("UniqueKey", mUsers);
startActivity(mIntent);

//Getting MyObject List
Intent mIntent = getIntent();
ArrayList<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");

Nota: esistono plugin Android Studio come questo disponibili per generare codice Parcelable

Serializable

Invio del codice attività

Product product = new Product();
Bundle bundle = new Bundle();
bundle.putSerializable("product", product);
Intent cartIntent = new Intent(mContext, ShowCartActivity.class);
cartIntent.putExtras(bundle);
mContext.startActivity(cartIntent);

Ricevere l'oggetto nell'attività di destinazione.

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Bundle bundle = this.getIntent().getExtras();
    Product product = null;
    if (bundle != null) {
        product = (Product) bundle.getSerializable("product");
    }

Arraylist di oggetto serializzabile: uguale al passaggio di un singolo oggetto

L'oggetto personalizzato dovrebbe implementare l'interfaccia Serializable .

Ottenere un risultato da Activity to Fragment

Come ottenere un risultato da un'altra attività, devi chiamare il metodo di Fragment startActivityForResult(Intent intent, int requestCode) . notare che non si dovrebbe chiamare getActivity().startActivityForResult() come questo richiederà il risultato di nuovo al Fragment genitore 's Activity .

La ricezione del risultato può essere eseguita utilizzando il metodo Fragment onActivityResult() . È necessario assicurarsi che l'attività padre di Fragment sovrascriva onActivityResult() e chiama la sua super implementazione.

Nell'esempio seguente ActivityOne contiene FragmentOne , che avvierà ActivityTwo e si aspetta un risultato da esso.

ActivityOne

public class ActivityOne extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }

    // You must override this method as the second Activity will always send its results to this Activity and then to the Fragment
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
       super.onActivityResult(requestCode, resultCode, data);
    }
}

activity_one.xml

<fragment android:name="com.example.FragmentOne"
    android:id="@+id/fragment_one"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

FragmentOne

public class FragmentOne extends Fragment {
    public static final int REQUEST_CODE = 11;
    public static final int RESULT_CODE = 12;
    public static final String EXTRA_KEY_TEST = "testKey";

    // Initializing and starting the second Activity
    private void startSecondActivity() {
        Intent intent = new Intent(getActivity(), ActivityTwo.class);
        startActivityForResult(REQUEST_CODE, intent);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CODE && resultCode == RESULT_CODE) {
            String testResult = data.getStringExtra(EXTRA_KEY_TEST);
            // TODO: Do something with your extra data
        }
    }
}

ActivityTwo

public class ActivityTwo extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_two);
    }

    private void closeActivity() {
        Intent intent = new Intent();
        intent.putExtra(FragmentOne.EXTRA_KEY_TEST, "Testing passing data back to ActivityOne");
        setResult(FragmentOne.RESULT_CODE, intent); // You can also send result without any data using setResult(int resultCode)
        finish();
    }
}