Android
voornemen

Invoering

Syntaxis

• Intent Intent ()
• Intent Intent (Intent intent)
• Intent Intent (Stringactie)
• Intent Intent (Stringactie, Uri uri)
• Intent Intent (ContextpakketContext, Class <?> Cls)
• Intent Intent (Stringactie, Uri uri, ContextpakketContext, Class <?> Cls)
• void startActivity (Intent intent)
• void startActivity (intentie, bundelopties)
• void startActivityForResult (Intent intent, int requestCode)
• void startActivityForResult (Intent intent, int requestCode, Bundle options)
• Intent putExtra (tekenreeksnaam, dubbele [] waarde)
• Intent putExtra (tekenreeksnaam, int-waarde)
• Intent putExtra (tekenreeksnaam, CharSequence-waarde)
• Intent putExtra (tekenreeksnaam, char-waarde)
• Intent putExtra (tekenreeksnaam, bundelwaarde)
• Intent putExtra (Stringnaam, Parcelable [] waarde)
• Intent putExtra (tekenreeksnaam, serialiseerbare waarde)
• Intent putExtra (tekenreeksnaam, int [] waarde)
• Intent putExtra (Stringnaam, floatwaarde)
• Intent putExtra (tekenreeksnaam, byte [] waarde)
• Intent putExtra (tekenreeksnaam, lange [] waarde)
• Intent putExtra (tekenreeksnaam, pakketwaarde)
• Intent putExtra (Stringnaam, float [] waarde)
• Intent putExtra (tekenreeksnaam, lange waarde)
• Intent putExtra (Stringnaam, String [] waarde)
• Intent putExtra (tekenreeksnaam, booleaanse waarde)
• Intent putExtra (tekenreeksnaam, booleaanse [] waarde)
• Intent putExtra (tekenreeksnaam, korte waarde)
• Intent putExtra (tekenreeksnaam, dubbele waarde)
• Intent putExtra (tekenreeksnaam, korte [] waarde)
• Intent putExtra (Stringnaam, Stringwaarde)
• Intent putExtra (tekenreeksnaam, bytewaarde)
• Intent putExtra (tekenreeksnaam, char [] waarde)
• Intent putExtra (tekenreeksnaam, CharSequence [] waarde)

parameters

Opmerkingen

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

Start een activiteit

In dit voorbeeld wordt DestinationActivity gestart vanuit OriginActivity .

Hier neemt de Intent constructor twee parameters:

1. Een context als eerste parameter (deze wordt gebruikt omdat de activiteitsklasse een subklasse van context is)
2. De klasse van de app-component waaraan het systeem de intentie moet leveren (in dit geval de activiteit die moet worden gestart)

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

Een andere manier om de Intent te creëren om DestinationActivity te openen, is door de standaardconstructor voor de Intent gebruiken en de methode setClass() gebruiken om aan te geven welke activiteit moet worden geopend:

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 

Gegevens doorgeven tussen activiteiten

Dit voorbeeld illustreert het verzenden van een String met waarde als "Some data!" van OriginActivity naar DestinationActivity .

OPMERKING: Dit is de meest eenvoudige manier om gegevens tussen twee activiteiten te verzenden. Zie het voorbeeld over het gebruik van het startpatroon voor een robuustere implementatie.

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

Het is ook mogelijk om andere passen primitive gegevenstypen en arrays , Bundle en Parcelable data. Het doorgeven van Serializable is ook mogelijk, maar moet worden vermeden omdat het meer dan drie keer langzamer is dan Parcelable .

Serializable is een standaard Java- interface . U markeert eenvoudig een klasse als Serializable door de Serializable interface implementeren en Java zal deze automatisch serieel maken in de vereiste situaties.

Parcelable is een Android-specifieke interface die kan worden geïmplementeerd op aangepaste gegevenstypen (dat wil zeggen uw eigen objecten / POJO-objecten), waarmee uw object kan worden afgeplat en zichzelf kan reconstrueren zonder dat de bestemming iets hoeft te doen. Er is een documentatievoorbeeld om een object pakketbaar te maken .

Zodra u een parcelable hebt, kunt u het verzenden als een primitief type, met een intentief object:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

Of in een bundel / als argument voor een fragment:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

en lees het dan ook vanuit de intentie op de bestemming met getParcelableExtra:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

Of bij het lezen van een fragment uit een bundel:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

Als u eenmaal een Serializable object hebt, kunt u dit in een intentieobject plaatsen:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

en lees het dan ook van het intent-object op de bestemming zoals hieronder getoond:

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

E-mails versturen

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

Hiermee wordt een e-mail vooraf ingevuld in een e-mailapp van de keuze van de gebruiker.

Als u een bijlage moet toevoegen, kunt u Intent.ACTION_SEND gebruiken Intent.ACTION_SEND plaats van Intent.ACTION_SENDTO . Voor meerdere bijlagen kunt u ACTION_SEND_MULTIPLE

Een waarschuwing: niet elk apparaat heeft een provider voor ACTION_SENDTO en het aanroepen van startActivity() zonder eerst te controleren met resolveActivity() kan een ActivityNotFoundException resolveActivity() .

Een resultaat krijgen van een andere activiteit

Door startActivityForResult(Intent intent, int requestCode) kunt u een andere Activity starten en vervolgens een resultaat van die Activity in de onActivityResult(int requestCode, int resultCode, Intent data) . Het resultaat wordt als een Intent geretourneerd. Een intentie kan gegevens bevatten via een bundel

In dit voorbeeld MainActivity zal een start DetailActivity en dan verwachten dat een resultaat van. Elk verzoektype moet zijn eigen int aanvraagcode hebben, zodat in de overschreven onActivityResult(int requestCode, int resultCode, Intent data) in MainActivity kan worden bepaald welk verzoek moet worden MainActivity door de waarden van requestCode en REQUEST_CODE_EXAMPLE (hoewel hier er is bijvoorbeeld maar één).

Hoofdactiviteit:

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

Een paar dingen waar u op moet letten:

• Gegevens worden alleen geretourneerd wanneer u finish() . U moet setResult() aanroepen voordat u finish() setResult() , anders wordt er geen resultaat geretourneerd.

• Zorg ervoor dat uw Activity geen android:launchMode="singleTask" , anders wordt de Activity uitgevoerd in een afzonderlijke taak en ontvangt u er geen resultaat van. Als uw Activity singleTask als singleTask gebruikt, wordt onActivityResult() met een resultaatcode van Activity.RESULT_CANCELED .

• Wees voorzichtig bij het gebruik van android:launchMode="singleInstance" . Op apparaten vóór Lollipop (Android 5.0, API-niveau 21) retourneren activiteiten geen resultaat.

• U kunt expliciete of impliciete intenties gebruiken wanneer u startActivityForResult() . Wanneer u een van uw eigen activiteiten start om een resultaat te ontvangen, moet u een expliciete intentie gebruiken om ervoor te zorgen dat u het verwachte resultaat ontvangt. Een expliciete intent wordt altijd geleverd aan zijn doel, ongeacht wat het bevat; het filter wordt niet geraadpleegd. Maar een impliciete intentie wordt alleen aan een component geleverd als deze door een van de filters van de component kan gaan.

Open een URL in een browser

Openen met de standaardbrowser

Dit voorbeeld laat zien hoe u een URL programmatisch kunt openen in de ingebouwde webbrowser in plaats van in uw toepassing. Hiermee kan uw app een webpagina openen zonder de INTERNET machtiging in uw manifestbestand op te nemen.

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

De gebruiker wordt gevraagd een browser te selecteren

Merk op dat dit voorbeeld de methode Intent.createChooser() gebruikt:

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 sommige gevallen kan de URL beginnen met "www" . Als dat het geval is, krijgt u deze uitzondering:

android.content.ActivityNotFoundException : Geen activiteit gevonden om Intent af te handelen

De URL moet altijd beginnen met "http: //" of "https: //" . Uw code moet daarom controleren, zoals weergegeven in het volgende codefragment:

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

Controleer of er geen apps op het apparaat zijn die de impliciete intentie kunnen ontvangen. Anders crasht uw app wanneer deze startActivity() aanroept. Om te verifiëren dat er een app bestaat om de intentie te ontvangen, roept u resolveActivity() op uw Intent-object. Als het resultaat niet nul is, is er ten minste één app die de intentie aankan en is het veilig om startActivity() aan te roepen. Als het resultaat nul is, moet u de intentie niet gebruiken en, indien mogelijk, de functie uitschakelen die de intentie oproept.

Een activiteitenstapel wissen

Soms wilt u misschien een nieuwe activiteit starten terwijl u eerdere activiteiten uit de back-stack verwijdert, zodat de terug-knop u niet terug naar hen brengt. Een voorbeeld hiervan is het starten van een app voor de aanmeldingsactiviteit, die u naar de hoofdactiviteit van uw toepassing leidt, maar bij het afmelden wilt u teruggaan naar de aanmelding zonder de kans om terug te gaan. In zo'n geval kunt u de vlag FLAG_ACTIVITY_CLEAR_TOP voor de intentie, wat betekent dat als de te starten activiteit al wordt uitgevoerd in de huidige taak (LoginActivity), dan in plaats van een nieuw exemplaar van die activiteit te starten, alle andere activiteiten bovenaan hiervan zal worden gesloten en deze intentie zal worden geleverd aan de (nu bovenaan) oude activiteit als een nieuwe intentie.

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

Het is ook mogelijk om de vlaggen FLAG_ACTIVITY_NEW_TASK samen met FLAG_ACTIVITY_CLEAR_TASK als u alle activiteiten op de achterste stapel wilt wissen:

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

Intentie URI

Dit voorbeeld laat zien hoe de intentie vanuit de browser kan worden gestart:

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

Deze intentie start de app met pakket com.sample.test of opent Google Play met dit pakket.

Ook deze intentie kan worden gestart met javascript:

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

In activiteit kunnen deze host en dit pad worden verkregen uit intentiegegevens:

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

Intentie URI-syntaxis:

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

Berichten uitzenden naar andere componenten

Intents kunnen worden gebruikt om berichten uit te zenden naar andere componenten van uw applicatie (zoals een actieve achtergronddienst) of naar het gehele Android-systeem.

Gebruik de klasse LocalBroadcastManager om een uitzending binnen uw toepassing te verzenden:

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

Als u een uitzending naar componenten buiten uw toepassing wilt verzenden, gebruikt u de methode sendBroadcast() op een Context object.

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

Informatie over het ontvangen van uitzendingen kunt u hier vinden: Broadcast Receiver

CustomTabsIntent voor Chrome Custom Tabs

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'

Meerdere bestanden delen via intentie

De tekenreekslijst die als parameter is doorgegeven aan de methode share() bevat de paden van alle bestanden die u wilt delen.

Het loopt in principe door de paden, voegt ze toe aan Uri en start de activiteit die bestanden van dit type kan accepteren.

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

Startpatroon

Dit patroon is een strengere aanpak voor het starten van een Activity . Het doel is om de leesbaarheid van de code te verbeteren en tegelijkertijd de complexiteit van de code, onderhoudskosten en koppeling van uw componenten te verminderen.

Het volgende voorbeeld implementeert het startpatroon, dat meestal wordt geïmplementeerd als een statische methode voor de Activity zelf. Deze statische methode accepteert alle vereiste parameters, construeert een geldige Intent van die gegevens en start vervolgens de Activity .

Een Intent is een object dat runtime-binding biedt tussen afzonderlijke componenten, zoals twee activiteiten. De intentie staat voor de 'intentie van een app om iets te doen'. Je kunt intenties gebruiken voor een breed scala aan taken, maar hier begint je intentie een andere activiteit.

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

Met dit patroon kunt u ook extra gegevens dwingen om met de bedoeling door te geven.

De ExampleActivity kan vervolgens op deze manier worden gestart, waarbij context een activiteitscontext is:

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

Start Ongebonden service met een intentie

Een service is een component die op de achtergrond (op de gebruikersinterface) wordt uitgevoerd zonder directe interactie met de gebruiker. Een ongebonden service is net gestart en is niet gebonden aan de levenscyclus van een activiteit.

Om een service te starten, kunt u doen zoals in het onderstaande voorbeeld:

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

U kunt eventuele extra's van de intentie gebruiken door een 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;
    }

}

Intentie delen

Deel eenvoudige informatie met verschillende 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)));

Deel een afbeelding met verschillende 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)));

Start de kiezer

Dit voorbeeld laat zien hoe u een standaardkiezer (een app die regelmatig belt) opent met een opgegeven telefoonnummer:

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

Resultaat van het uitvoeren van de bovenstaande code:

Open Google map met opgegeven lengte- en breedtegraad

U kunt via Intent latitude, longitude van uw app naar Google map doorgeven

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

Verschillende gegevens doorgeven via intentie in activiteit

1. Passing integer data:

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. Dubbele gegevens doorgeven:

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. Passing String gegevens:

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

of

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

4. Gegevens van ArrayList doorgeven:

SenderActivity

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

ReceiverActivity

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

5. Gegevens van passerende objecten:

SenderActivity

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

ReceiverActivity

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

Opmerking: houd er rekening mee dat uw aangepaste klasse de interface Serializable moet implementeren.

6. Gegevens van HashMap <String, String> doorgeven:

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. Bitmap-gegevens doorgeven:

SenderActivity

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

ReceiverActivity

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

Een bestandskiezer tonen en het resultaat lezen

Een activiteit voor het kiezen van bestanden 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);
}

Het resultaat lezen

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

Aangepast object doorgeven tussen activiteiten

Het is ook mogelijk om uw aangepaste object door te geven aan andere activiteiten met de klasse Bundle .

Er zijn twee manieren:

• Serializable interface - voor Java en Android
• Parcelable interface - geheugenefficiënt, alleen voor Android (aanbevolen)

Parcelable

De verwerking van pakketten is veel sneller dan serialiseerbaar. Een van de redenen hiervoor is dat we expliciet zijn over het serialisatieproces in plaats van reflectie te gebruiken om het af te leiden. Het spreekt ook voor zich dat de code voor dit doel sterk is geoptimaliseerd.

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

Activiteitcode verzenden

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

Het object ontvangen in doelactiviteit.

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

U kunt het Arraylist of Parceble-object doorgeven zoals hieronder

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

Opmerking: er zijn Android Studio-plug-ins zoals deze beschikbaar om pakketcode te genereren

serializable

Activiteitcode verzenden

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

Het object ontvangen in doelactiviteit.

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 of Serializable object: hetzelfde als het passeren van een enkel object

Aangepast object moet de interface Serializable implementeren.

Een resultaat krijgen van activiteit naar fragment

Als je een resultaat wilt krijgen van een andere activiteit , moet je de methode startActivityForResult(Intent intent, int requestCode) het Fragment aanroepen startActivityForResult(Intent intent, int requestCode) . merk op dat u getActivity().startActivityForResult() niet moet aanroepen getActivity().startActivityForResult() omdat dit het resultaat terugbrengt naar de bovenliggende Activity van het Fragment .

Het ontvangen van het resultaat kan worden gedaan met behulp van de methode Fragment onActivityResult() . Je moet ervoor zorgen dat de bovenliggende activiteit van het Fragment ook voorrang heeft onActivityResult() en het super implementatie noemt.

In het volgende voorbeeld bevat ActivityOne FragmentOne , waarmee ActivityTwo wordt gestart en er een resultaat van wordt verwacht.

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