Android
Absicht

Einführung

Syntax

• Absicht Absicht ()
• Vorsatz (Vorsatz)
• Absicht Absicht (String-Aktion)
• Intent Intent (String-Aktion, Uri Uri)
• Intent Intent (Context packageContext, Klasse <?> Cls)
• Intent Intent (String-Aktion, Uri-Uri, KontextpaketContext, Klasse <?> Cls)
• void startActivity (Absichtsabsicht)
• void startActivity (Absichtsabsicht, Bundle-Optionen)
• void startActivityForResult (Absichtsabsicht, int requestCode)
• void startActivityForResult (Intent Intent, Int requestCode, Bundle-Optionen)
• Intention putExtra (Stringname, doppelter [] -Wert)
• Intention putExtra (Stringname, int-Wert)
• Intention putExtra (String-Name, CharSequence-Wert)
• Intention putExtra (String-Name, Char-Wert)
• Intention putExtra (Stringname, Bundle-Wert)
• Intention putExtra (String-Name, Wert für Parcelable [])
• Intention putExtra (Stringname, serialisierbarer Wert)
• Intention putExtra (Stringname, int [] -Wert)
• Intention putExtra (Stringname, Gleitkommawert)
• Intention putExtra (Stringname, Byte [] -Wert)
• Intention putExtra (Stringname, langer [] -Wert)
• Intention putExtra (Stringname, Wert für Parcelable)
• Intention putExtra (Stringname, Gleitkommawert [])
• Intention putExtra (Stringname, langer Wert)
• Intention putExtra (Stringname, String [] -Wert)
• Intention putExtra (Stringname, boolescher Wert)
• Intention putExtra (Stringname, boolescher [] -Wert)
• Intention putExtra (Stringname, kurzer Wert)
• Intention putExtra (Stringname, doppelter Wert)
• Intention putExtra (Stringname, kurzer [] -Wert)
• Intention putExtra (Stringname, Stringwert)
• Intention putExtra (Stringname, Byte-Wert)
• Intention putExtra (Stringname, char [] -Wert)
• Intention putExtra (Stringname, CharSequence [] -Wert)

Parameter

Bemerkungen

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

Eine Aktivität starten

In diesem Beispiel wird DestinationActivity von OriginActivity aus OriginActivity .

Hier nimmt der Intent Konstruktor zwei Parameter an:

1. Ein Kontext als erster Parameter (wird verwendet, da die Activity-Klasse eine Unterklasse von Context ist)
2. Die Klasse der App-Komponente, an die das System die Absicht liefern soll (in diesem Fall die Aktivität, die gestartet werden soll)

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.
    }
}

Eine andere Methode zum Erstellen des Intent zum Öffnen von DestinationActivity besteht darin, den Standardkonstruktor für den Intent und die setClass() Methode zu verwenden, um setClass() , welche Aktivität geöffnet werden soll:

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 

Weitergabe von Daten zwischen Aktivitäten

Dieses Beispiel zeigt das Senden eines String mit dem Wert "Some data!" von OriginActivity zu DestinationActivity .

HINWEIS: Dies ist der einfachste Weg, Daten zwischen zwei Aktivitäten zu senden. Im Beispiel zur Verwendung des Startermusters finden Sie eine robustere Implementierung.

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);
    }
}

Es ist auch möglich , andere passieren primitive Datentypen sowie arrays , Bundle und Parcelable Daten. Das Passieren von Serializable ist ebenfalls möglich, sollte jedoch vermieden werden, da es mehr als dreimal langsamer ist als Parcelable .

Serializable ist eine Standard-Java- interface . Sie können eine Klasse einfach als Serializable markieren, indem Sie die Serializable interface implementieren interface und Java wird sie in den erforderlichen Situationen automatisch serialisieren.

Parcelable ist eine Android-spezifische interface die für benutzerdefinierte Datentypen (z. B. eigene Objekte / POJO-Objekte) implementiert werden kann. Dadurch kann Ihr Objekt reduziert werden und sich selbst rekonstruieren, ohne dass das Ziel etwas tun muss. Es gibt ein Dokumentationsbeispiel , um ein Objekt parcelabel zu machen .

Sobald Sie ein parcelable Objekt haben, können Sie es wie ein primitiver Typ mit einem Intent-Objekt senden:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

Oder in einem Bundle / als Argument für ein Fragment:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

und dann mit getParcelableExtra aus dem Intent am Ziel lesen:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

Oder wenn Sie ein Fragment aus einem Bundle einlesen:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

Sobald Sie ein Serializable Objekt haben, können Sie es in ein Intent-Objekt einfügen:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

und dann lesen Sie es auch aus dem Intent-Objekt am Ziel, wie unten gezeigt:

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

E-Mails senden

// 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
}

Dadurch wird eine E-Mail in einer E-Mail-App nach Wahl des Benutzers ausgefüllt.

Wenn Sie einen Anhang hinzufügen müssen, können Sie Intent.ACTION_SEND anstelle von Intent.ACTION_SENDTO . Für mehrere Anhänge können Sie ACTION_SEND_MULTIPLE

Ein Wort der Vorsicht: Nicht jedes Gerät hat einen Provider für ACTION_SENDTO , und der Aufruf von startActivity() ohne resolveActivity() Überprüfung mit resolveActivity() kann eine ActivityNotFoundException resolveActivity() .

Ein Ergebnis aus einer anderen Aktivität erhalten

Mit startActivityForResult(Intent intent, int requestCode) Sie eine andere Activity starten und dann ein Ergebnis dieser Activity in der onActivityResult(int requestCode, int resultCode, Intent data) . Das Ergebnis wird als Intent . Ein Intent kann Daten über ein Bundle enthalten

In diesem Beispiel MainActivity eine DetailActivity und erwartet dann ein Ergebnis. Jeder onActivityResult(int requestCode, int resultCode, Intent data) sollte seinen eigenen int Anforderungscode haben, sodass in der überschriebenen onActivityResult(int requestCode, int resultCode, Intent data) in MainActivity werden kann, welche Anforderung verarbeitet werden soll, indem die Werte von requestCode und REQUEST_CODE_EXAMPLE (obwohl in diesem REQUEST_CODE_EXAMPLE verglichen werden Beispiel gibt es nur einen).

Hauptaktivität:

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.
            }
        }
    }
}

DetailAktivität:

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();
    }
}

Ein paar Dinge, die Sie beachten sollten:

• Daten werden nur zurückgegeben, wenn Sie finish() aufrufen. Sie müssen setResult() aufrufen, bevor Sie finish() aufrufen. Andernfalls wird kein Ergebnis zurückgegeben.

• android:launchMode="singleTask" Sie sicher, dass Ihre Activity android:launchMode="singleTask" nicht verwendet android:launchMode="singleTask" wird die Activity in einer separaten Task ausgeführt. Daher erhalten Sie kein Ergebnis. Wenn Ihre Activity singleTask als Startmodus verwendet, wird onActivityResult() sofort mit dem Ergebniscode Activity.RESULT_CANCELED onActivityResult() .

• Seien Sie vorsichtig bei der Verwendung von android:launchMode="singleInstance" . Auf Geräten vor Lollipop (Android 5.0, API Level 21) wird von Aktivitäten kein Ergebnis zurückgegeben.

• Sie können explizite oder implizite Absichten verwenden, wenn Sie startActivityForResult() aufrufen. Wenn Sie eine Ihrer eigenen Aktivitäten starten, um ein Ergebnis zu erhalten, sollten Sie eine explizite Absicht verwenden, um sicherzustellen, dass Sie das erwartete Ergebnis erhalten. Eine explizite intent wird immer an das Ziel geliefert, egal was es enthält. der filter wird nicht konsultiert. Eine implizite Absicht wird jedoch nur dann an eine Komponente übergeben, wenn sie einen der Filter der Komponente passieren kann.

Öffnen Sie eine URL in einem Browser

Mit dem Standardbrowser öffnen

Dieses Beispiel zeigt, wie Sie eine URL programmgesteuert im integrierten Webbrowser und nicht in Ihrer Anwendung öffnen können. Dadurch kann Ihre App eine Webseite öffnen, ohne dass die INTERNET Berechtigung in Ihre Manifestdatei eingefügt werden muss.

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);
    } 
}

Aufforderung an den Benutzer, einen Browser auszuwählen

Beachten Sie, dass dieses Beispiel die Methode Intent.createChooser() verwendet:

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 einigen Fällen kann die URL mit "www" beginnen . In diesem Fall erhalten Sie diese Ausnahme:

android.content.ActivityNotFoundException : Es wurde keine Aktivität zum android.content.ActivityNotFoundException Absicht gefunden

Die URL muss immer mit "http: //" oder "https: //" beginnen . Ihr Code sollte daher prüfen, wie im folgenden Code-Snippet gezeigt:

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);
} 

Best Practices

Prüfen Sie, ob sich auf dem Gerät keine Apps befinden, die die implizite Absicht erhalten können. Andernfalls stürzt Ihre App ab, wenn sie startActivity() . Um zunächst zu überprüfen, ob eine App vorhanden ist, um die Absicht zu erhalten, rufen Sie resolveActivity() für Ihr Intent-Objekt auf. Wenn das Ergebnis nicht null ist, gibt es mindestens eine App, die die Absicht verarbeiten kann, und es ist sicher, startActivity() . Wenn das Ergebnis null ist, sollten Sie die Absicht nicht verwenden und wenn möglich, sollten Sie die Funktion deaktivieren, die die Absicht aufruft.

Löschen eines Aktivitätsstapels

Manchmal möchten Sie möglicherweise eine neue Aktivität starten, während Sie vorherige Aktivitäten aus dem hinteren Stapel entfernen, sodass Sie mit der Zurück-Schaltfläche nicht wieder zu ihnen zurückkehren können. Ein Beispiel hierfür könnte das Starten einer App in der Login-Aktivität sein, die Sie zur Main-Aktivität Ihrer Anwendung führt. Beim Abmelden möchten Sie jedoch zurück zum Login geleitet werden, ohne die Möglichkeit zur erneuten Anmeldung. In einem FLAG_ACTIVITY_CLEAR_TOP Fall können Sie das Flag FLAG_ACTIVITY_CLEAR_TOP für die Absicht FLAG_ACTIVITY_CLEAR_TOP , d. FLAG_ACTIVITY_CLEAR_TOP , Wenn die gerade gestartete Aktivität bereits in der aktuellen Task (LoginActivity) ausgeführt wird, und nicht eine neue Instanz dieser Aktivität, sondern alle anderen Aktivitäten oben Davon wird geschlossen, und diese Absicht wird als (neue) Aktivität an die (jetzt oben) alte Aktivität übergeben.

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

Sie können auch die Flags FLAG_ACTIVITY_NEW_TASK zusammen mit FLAG_ACTIVITY_CLEAR_TASK wenn Sie alle Aktivitäten auf dem FLAG_ACTIVITY_NEW_TASK FLAG_ACTIVITY_CLEAR_TASK möchten:

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);

Beabsichtigte URI

Dieses Beispiel zeigt, wie Sie die Absicht vom Browser aus starten:

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

Diese Absicht startet die App mit dem Paket com.sample.test oder öffnet Google Play mit diesem Paket.

Auch diese Absicht kann mit Javascript gestartet werden:

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

In der Aktivität können dieser Host und dieser Pfad aus Absichtsdaten erhalten werden:

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

Intent URI-Syntax:

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

Senden von Nachrichten an andere Komponenten

Absichten können verwendet werden, um Nachrichten an andere Komponenten Ihrer Anwendung (z. B. einen laufenden Hintergrunddienst) oder an das gesamte Android-System zu senden.

Verwenden LocalBroadcastManager zum Senden einer Übertragung innerhalb Ihrer Anwendung die LocalBroadcastManager Klasse:

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);

Um ein Broadcast an Komponenten außerhalb Ihrer Anwendung zu senden, verwenden Sie die sendBroadcast() -Methode für ein Context Objekt.

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);

Informationen zum Empfang von Broadcasts finden Sie hier: Broadcast Receiver

CustomTabsIntent für benutzerdefinierte Registerkarten

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'

Gemeinsame Verwendung mehrerer Dateien

Die String-Liste, die der share() -Methode als Parameter übergeben wird, enthält die Pfade aller Dateien, die Sie freigeben möchten.

Es durchläuft im Wesentlichen die Pfade, fügt sie zu Uri hinzu und startet die Aktivität, die Dateien dieses Typs annehmen kann.

  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);
    }

Starter-Muster

Dieses Muster ist ein strengerer Ansatz, um eine Activity zu starten. Ihr Zweck besteht darin, die Lesbarkeit des Codes zu verbessern und gleichzeitig die Komplexität des Codes, die Wartungskosten und die Kopplung Ihrer Komponenten zu reduzieren.

Im folgenden Beispiel wird das Startermuster implementiert, das normalerweise als statische Methode für die Activity selbst implementiert wird. Diese statische Methode akzeptiert alle erforderlichen Parameter, erstellt aus diesen Daten eine gültige Intent und startet dann die Activity .

Ein Intent ist ein Objekt, das Laufzeitbindung zwischen separaten Komponenten, z. B. zwei Aktivitäten, bereitstellt. Die Absicht repräsentiert die Absicht einer App, etwas zu tun. Sie können Absichten für eine Vielzahl von Aufgaben verwenden, aber hier beginnt Ihre Absicht mit einer anderen Aktivität.

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);
    }
}

Mit diesem Muster können Sie auch erzwingen, dass zusätzliche Daten mit der Absicht übergeben werden.

Die ExampleActivity kann dann wie ExampleActivity gestartet werden, wobei context ein Aktivitätskontext ist:

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

Starten Sie Unbound Service mit einer Absicht

Ein Service ist eine Komponente, die im Hintergrund (im UI-Thread) ohne direkte Interaktion mit dem Benutzer ausgeführt wird. Ein ungebundener Dienst wird gerade gestartet und ist nicht an den Lebenszyklus einer Aktivität gebunden.

Um einen Dienst zu starten, können Sie wie im folgenden Beispiel gezeigt:

// 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);

Sie können alle Extras der Absicht verwenden, indem Sie eine onStartCommand() Überschreibung verwenden:

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;
    }

}

Absicht teilen

Teilen Sie einfache Informationen mit verschiedenen Apps.

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)));

Teilen Sie ein Bild mit verschiedenen Apps.

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)));

Starten Sie den Dialer

In diesem Beispiel wird gezeigt, wie ein Standardwählgerät (eine App, die normale Anrufe tätigt) mit einer vorhandenen Telefonnummer geöffnet wird:

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);

Ergebnis durch Ausführen des obigen Codes:

Google-Karte mit angegebenem Breitengrad und Längengrad öffnen

Mit Intent können Sie Breiten- und Längengrade von Ihrer App an die Google-Karte übergeben

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);

Weitergabe verschiedener Daten durch Intent in Activity

1. Übergeben von Integer-Daten:

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. Doppeldaten übergeben:

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. String-Daten übergeben:

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");

oder

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

4. Übergeben von ArrayList-Daten:

SenderActivity

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

ReceiverActivity

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

5. Objektdaten übergeben:

SenderActivity

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

ReceiverActivity

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

Hinweis: Denken Sie daran, dass Ihre benutzerdefinierte Klasse die Serializable Schnittstelle implementieren muss.

6. HashMap-Daten <String, String> übergeben:

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. Übergeben von Bitmap-Daten:

SenderActivity

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

ReceiverActivity

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

Anzeigen einer Dateiauswahl und Lesen des Ergebnisses

Dateiauswahl-Aktivität starten

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);
}

Lesen Sie das Ergebnis

@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;
}

Benutzerdefiniertes Objekt zwischen Aktivitäten übergeben

Mit der Bundle Klasse können Sie Ihr benutzerdefiniertes Objekt auch an andere Aktivitäten übergeben.

Es gibt zwei Möglichkeiten:

• Serializable Schnittstelle - für Java und Android
• Parcelable Schnittstelle - speichereffizient, nur für Android (empfohlen)

Paketierbar

Die Verarbeitung per Paket ist viel schneller als die Serialisierung. Einer der Gründe dafür ist, dass wir den Serialisierungsprozess explizit machen, anstatt ihn anhand von Reflektionen abzuleiten. Es versteht sich auch, dass der Code für diesen Zweck stark optimiert wurde.

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);
        }
    };
}

Code zum Senden von Aktivitäten

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);

Empfangen des Objekts in der Zielaktivität.

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

Sie können das Arraylist of Parceble-Objekt wie folgt übergeben

//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");

Hinweis: Es gibt Android Studio-Plugins wie dieses , um Parcelable-Code zu generieren

Serialisierbar

Code zum Senden von Aktivitäten

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);

Empfangen des Objekts in der Zielaktivität.

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 des serialisierbaren Objekts: wie beim Durchgang einzelner Objekte

Benutzerdefiniertes Objekt sollte die Serializable Schnittstelle implementieren.

Ergebnis von Aktivität in Fragment berechnen

Wie beim Abrufen eines Ergebnisses aus einer anderen Aktivität müssen Sie die Methode startActivityForResult(Intent intent, int requestCode) des Fragment startActivityForResult(Intent intent, int requestCode) . Beachten Sie, dass Sie getActivity().startActivityForResult() nicht aufrufen getActivity().startActivityForResult() da dies das Ergebnis zur übergeordneten Activity des Fragment zurückgibt.

Das Ergebnis kann mit der Fragment onActivityResult() . Sie müssen sicherstellen, dass die übergeordnete Activity des Fragments auch onActivityResult() überschreibt und die Implementierung als super .

Im folgenden Beispiel enthält ActivityOne FragmentOne , das ActivityTwo startet und ein Ergebnis davon erwartet.

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
        }
    }
}

AktivitätZwei

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();
    }
}