Android
Avsikt

Introduktion

Syntax

• Intent Intent ()
• Intent Intent (Intent intention)
• Intent Intent (String action)
• Intent Intent (String action, Uri uri)
• Intent Intent (Context packageContext, Class <?> Cls)
• Intent Intent (String action, Uri uri, Context packageContext, Class <?> Cls)
• void startActivity (Intent intention)
• void startActivity (Intent intention, Bundle-alternativ)
• void startActivityForResult (Intent intention, int requestCode)
• void startActivityForResult (Intent intention, int requestCode, Bundle-alternativ)
• Intent putExtra (String name, double [] value)
• Intent putExtra (String name, int value)
• Intent putExtra (String name, CharSequence value)
• Intent putExtra (String name, char value)
• Syfte putExtra (String name, Bundle value)
• Intent putExtra (String name, Parcelable [] value)
• Intent putExtra (String name, Serializable value)
• Intent putExtra (String name, int [] value)
• Intent putExtra (String name, float value)
• Intent putExtra (String name, byte [] -värde)
• Intent putExtra (String name, long [] value)
• Intent putExtra (String name, Parcelable value)
• Intent putExtra (String name, float [] -värde)
• Syfte putExtra (Strängnamn, långt värde)
• Intent putExtra (String name, String [] value)
• Avsikt putExtra (Stringnamn, booleskt värde)
• Intent putExtra (String name, boolean [] value)
• Intent putExtra (String name, short value)
• Intent putExtra (String name, double value)
• Intent putExtra (String name, short [] value)
• Syfte putExtra (String name, String value)
• Intent putExtra (String name, byte value)
• Intent putExtra (String name, char [] value)
• Intent putExtra (String name, CharSequence [] -värde)

parametrar

Anmärkningar

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

Starta en aktivitet

Detta exempel startar DestinationActivity från OriginActivity .

Här tar Intent konstruktören två parametrar:

1. En kontext som sin första parameter (detta används eftersom Aktivitetsklassen är en underklass av kontext)
2. Klassen för appkomponenten som systemet ska leverera avsikten till (i detta fall den aktivitet som bör startas)

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

Ett annat sätt att skapa Intent to open DestinationActivity är att använda standardkonstruktören för Intent och använda setClass() för att berätta vilken aktivitet som ska öppnas:

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 

Vidarebefordra data mellan aktiviteter

Detta exempel illustrerar att du skickar en String med värde som "Some data!" från OriginActivity to DestinationActivity .

OBS: Detta är det mest enkla sättet att skicka data mellan två aktiviteter. Se exemplet om att använda startmönstret för en mer robust implementering.

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

Det är också möjligt att passera andra primitive datatyper samt arrays , Bundle och Parcelable data. Att passera Serializable är också möjligt, men bör undvikas eftersom det är mer än tre gånger långsammare än Parcelable .

Serializable är ett vanligt Java- interface . Du markerar helt enkelt en klass som Serializable genom att implementera Serializable interface och Java kommer automatiskt att serialisera den under nödvändiga situationer.

Parcelable är ett Android-specifikt interface som kan implementeras på anpassade datatyper (dvs. dina egna objekt / POJO-objekt), det gör att ditt objekt kan plattas och rekonstrueras själv utan att destinationen behöver göra något. Det finns ett dokumentationsexempel på att göra ett objekt paketbart .

När du har ett parcelable du skicka det som en primitiv typ, med ett avsiktligt objekt:

intent.putExtra(DestinationActivity.EXTRA_DATA, myParcelableObject);

Eller i ett paket / som ett argument för ett fragment:

bundle.putParcelable(DestinationActivity.EXTRA_DATA, myParcelableObject);

och läs sedan också det från avsikten vid destinationen med getParcelableExtra:

final MyParcelableType data = intent.getParcelableExtra(EXTRA_DATA); 

Eller när du läser i ett fragment från ett paket:

final MyParcelableType data = bundle.getParcelable(EXTRA_DATA); 

När du har ett Serializable objekt kan du lägga det i ett avsiktligt objekt:

bundle.putSerializable(DestinationActivity.EXTRA_DATA, mySerializableObject);

och läs sedan också det från avsiktsobjektet vid destinationen som visas nedan:

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

Skickar e-post

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

Detta kommer att fylla i ett e-postmeddelande i en e-postapp efter användarens val.

Om du behöver lägga till en bilaga kan du använda Intent.ACTION_SEND istället för Intent.ACTION_SENDTO . För flera bilagor kan du använda ACTION_SEND_MULTIPLE

Ett försiktighetsord: inte alla enheter har en leverantör för ACTION_SENDTO och att ringa startActivity() utan att kontrollera med resolveActivity() först kan kasta en ActivityNotFoundException.

Få resultat från en annan aktivitet

Genom att använda startActivityForResult(Intent intent, int requestCode) du starta en annan Activity och sedan få ett resultat från den Activity i onActivityResult(int requestCode, int resultCode, Intent data) . Resultatet returneras som Intent . En avsikt kan innehålla data via ett paket

I det här exemplet kommer MainActivity att starta en DetailActivity och sedan förvänta sig ett resultat från den. Varje förfrågningstyp ska ha sin egen int begärandeskod, så att det i den åsidosatta onActivityResult(int requestCode, int resultCode, Intent data) -metoden i MainActivity kan bestämmas vilken begäran som ska behandlas genom att jämföra värden på requestCode och REQUEST_CODE_EXAMPLE (dock i detta exempel finns det bara en).

Huvudaktivitet:

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

Några saker du behöver vara medveten om:

• Data returneras endast när du ringer finish() . Du måste ringa setResult() innan samtalet setResult() finish() , annars kommer inget resultat att returneras.

• Se till att din Activity inte använder android:launchMode="singleTask" , så att Activity körs i en separat uppgift och att du därför inte får något resultat från den. Om din Activity använder singleTask som singleTask kommer den att ringa onActivityResult() omedelbart med en resultatkod för Activity.RESULT_CANCELED .

• Var försiktig när du använder android:launchMode="singleInstance" . På enheter före Lollipop (Android 5.0, API-nivå 21) kommer aktiviteter inte att returnera ett resultat.

• Du kan använda uttryckliga eller implicita avsikter när du ringer startActivityForResult() . När du startar en av dina egna aktiviteter för att få ett resultat, bör du använda en uttrycklig avsikt för att se till att du får det förväntade resultatet. En uttrycklig intent levereras alltid till dess mål, oavsett vad den innehåller; filter konsulteras inte. Men en implicit avsikt levereras till en komponent endast om den kan passera genom ett av komponentens filter.

Öppna en URL i en webbläsare

Öppnar med standardwebbläsaren

Detta exempel visar hur du kan öppna en URL programmatiskt i den inbyggda webbläsaren snarare än i din applikation. Detta gör att din app kan öppna en webbsida utan att behöva ta med INTERNET behörighet i din manifestfil.

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

Ber användaren att välja en webbläsare

Observera att detta exempel använder 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"));
   
}

I vissa fall kan webbadressen börja med "www" . Om så är fallet får du detta undantag:

android.content.ActivityNotFoundException : Ingen aktivitet hittades för att hantera avsikt

Webbadressen måste alltid börja med "http: //" eller "https: //" . Din kod bör därför se efter den, som visas i följande kodavsnitt:

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

Bästa praxis

Kontrollera om det inte finns några appar på enheten som kan få den implicita avsikten. Annars kraschar din app när den kallar startActivity() . För att först verifiera att en app finns för att få avsikten, ring resolveActivity() på ditt Intent-objekt. Om resultatet är icke-null finns det minst en app som kan hantera avsikten och det är säkert att ringa startActivity() . Om resultatet är noll ska du inte använda avsikten och om möjligt ska du inaktivera funktionen som åberopar avsikten.

Rensar en aktivitetsstapel

Ibland kanske du vill starta en ny aktivitet medan du tar bort tidigare aktiviteter från bakstacken, så att tillbaka-knappen inte tar dig tillbaka till dem. Ett exempel på detta kan vara att starta en app på inloggningsaktiviteten, ta dig till huvudaktiviteten i din applikation, men när du loggar ut vill du ledas tillbaka till inloggning utan chans att gå tillbaka. I ett sådant fall kan du ställa in FLAG_ACTIVITY_CLEAR_TOP flaggan för avsikten, vilket betyder att om aktiviteten som startas redan körs i den aktuella uppgiften (LoginActivity), istället för att lansera en ny instans av den aktiviteten, alla andra aktiviteter på toppen av den kommer att stängas och denna avsikt kommer att levereras till den (nu på toppen) gamla aktiviteten som en ny avsikt.

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

Det är också möjligt att använda flaggorna FLAG_ACTIVITY_NEW_TASK tillsammans med FLAG_ACTIVITY_CLEAR_TASK om du vill rensa alla aktiviteter på baksidan:

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

Avsikt URI

Detta exempel visar hur du startar avsikt från webbläsaren:

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

Denna avsikt startar appen med paketet com.sample.test eller öppnar google play med det här paketet.

Även denna avsikt kan startas med javascript:

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

I aktivitet kan denna värd och sökväg erhållas från avsiktdata:

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

Sända meddelanden till andra komponenter

Avsnitt kan användas för att sända meddelanden till andra komponenter i din applikation (som en bakgrundstjänst som körs) eller till hela Android-systemet.

Om du LocalBroadcastManager skicka en sändning inom din applikation använder LocalBroadcastManager klassen 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);

För att skicka en sändning till komponenter utanför din applikation använder sendBroadcast() metoden sendBroadcast() på ett 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);

Information om mottagande av sändningar hittar du här: Broadcastmottagare

CustomTabsIntent för Chrome Custom flikar

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'

Dela flera filer genom avsikt

Stränglistan som skickas som en parameter till metoden share() innehåller sökvägarna för alla filer du vill dela.

Det loppar i princip genom banorna, lägger till dem i Uri och startar aktiviteten som kan acceptera filer av denna typ.

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

Startmönster

Det här mönstret är ett striktare sätt att starta en Activity . Syftet är att förbättra kodläsbarheten och samtidigt minska kodens komplexitet, underhållskostnader och koppling av dina komponenter.

Följande exempel implementerar startmönstret, som vanligtvis implementeras som en statisk metod på själva Activity . Denna statiska metod accepterar alla nödvändiga parametrar, konstruerar en giltig Intent från den informationen och startar sedan Activity .

En Intent är ett objekt som ger runtime-bindning mellan separata komponenter, till exempel två aktiviteter. Avsikten representerar en apps "avsikt att göra något." Du kan använda avsikter för en mängd olika uppgifter, men här startar din avsikt en annan aktivitet.

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

Detta mönster tillåter dig också att tvinga ytterligare data att skickas med avsikt.

ExampleActivity kan sedan startas så här, där context är en aktivitetskontekst:

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

Starta obundet service med avsikt

En tjänst är en komponent som körs i bakgrunden (på UI-tråden) utan direkt interaktion med användaren. En obunden tjänst har just startat och är inte bunden till livscykeln för någon aktivitet.

För att starta en tjänst kan du göra som visas i exemplet nedan:

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

Du kan använda alla extrafunktioner från avsikten genom att använda en onStartCommand() åsidosättande:

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

}

Dela avsikt

Dela enkel information med olika appar.

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

Dela en bild med olika appar.

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

Starta uppringaren

Detta exempel visar hur man öppnar en standarduppringare (en app som ringer vanliga samtal) med ett tillhandahållet telefonnummer som redan finns:

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

Resultat från att köra koden ovan:

Öppna Google-karta med specificerad latitud, longitud

Du kan skicka latitud, longitud från din app till Google-karta med avsikt

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

Vidarebefordra olika data genom avsikt i aktivitet

1. Skicka heltalsdata:

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. Skicka dubbel data:

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. Vidarebefordra strängdata:

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

eller

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

4. Skickar ArrayList-data:

SenderActivity

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

ReceiverActivity

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

5. Skicka objektdata:

SenderActivity

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

ReceiverActivity

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

Obs: Kom ihåg att din anpassade klass måste implementera det Serializable gränssnittet.

6. Passing HashMap <String, String> data:

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. Skicka bitmappsdata:

SenderActivity

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

ReceiverActivity

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

Visar en filväljare och läser resultatet

Starta en filväljaraktivitet

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

Läser resultatet

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

Att skicka anpassat objekt mellan aktiviteter

Det är också möjligt att skicka ditt anpassade objekt till andra aktiviteter med hjälp av klassen Bundle .

Det finns två sätt:

• Serializable gränssnitt - för Java och Android
• Parcelable , endast för Android (rekommenderas)

Parcelable

Paketbearbetning är mycket snabbare än seriellt. En av orsakerna till detta är att vi uttryckligen talar om serieprocessen istället för att använda reflektion för att dra slutsatsen. Det är också uppenbart att koden är kraftigt optimerad för detta ändamål.

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

Skicka aktivitetskod

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

Ta emot objektet i destinationsaktivitet.

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

Du kan passera Arraylist of Parceble-objekt som nedan

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

Obs! Det finns Android Studio-plugins som den här för att generera paketkod

serializable

Skicka aktivitetskod

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

Ta emot objektet i destinationsaktivitet.

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: samma som en enda objekt som passerar

Anpassat objekt ska implementera det Serializable gränssnittet.

Få resultat från aktivitet till fragment

Som att få ett resultat från en annan aktivitet måste du kalla Fragment metod startActivityForResult(Intent intent, int requestCode) . Observera att du inte bör ringa getActivity().startActivityForResult() eftersom detta kommer att ta resultatet tillbaka till Fragment överordnade Activity .

Mottagning av resultatet kan göras med hjälp av Fragment metod onActivityResult() . Du måste se till att Fragmentets överordnade aktivitet också åsidosätter onActivityResult() och kallar det super .

I följande exempel innehåller ActivityOne FragmentOne , som startar ActivityTwo och förväntar sig ett resultat av det.

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