Kierunek Informatyka
Instrukcja do ćwiczeń laboratoryjnych nr:		5	Nazwa przedmiotu: Programowanie aplikacji mobilnych
Temat: intencje niejawienie zdefiniowane				Tryb studiów: stacjonarne
				Czas trwanie ćw. 2x45 min
Autor materiałów: dr Marcin Skuba

1. Treści programowe:

Tworzenie nowych aktywności. Intencje. Przekazywanie wartości przez intencje. Intencje wywołujące aktywności w sposób jawny i niejawny.

2. Cel zajęć:

Celem zajęć jest opanowanie umiejętności uruchamiania nowych aktywności poprzez Intencje oraz przekazywanie danych pomiędzy aktywnościami również przez Intencje.

3. Materiały dydaktyczne

Intencje są jednym z podstawowych komponentów aplikacji w systemie Android. Intencje odpowiadają przede wszystkim za obsługę rozkazów wydawanych przez użytkownika np.: „zrób zdjęcie”, zadzwoń do …”, „uruchom okno”. Najważniejszym zadaniem Intencji jest uruchamianie odpowiednich Aktywności.

Intencje możemy używać do uruchamiania innych aktywności w sposób jawny oraz niejawny.

- Niejawne definiowanie Aktywności – to takie, gdzie nie podajemy konkretnej nazwy klasy, tylko mówimy co chcemy zrobić i na jakich danych chcemy tę czynność wykonać. System sam dopasuje istniejącą Aktywność, których w systemie może być więcej niż jedna. Dokładne sprecyzowanie, która aktywność będzie najlepsza odbywa się poprzez filtry (będą omawiane na zajęciach w przyszłości).

ü Akcje – ACTION

Akcja systemowa to wbudowana akcja systemu Android, zdefiniowana przez Google.
Służy do dzielenia się danymi (np. tekstem, obrazem, plikiem) z innymi aplikacjami.

ACTION w Androidzie to stała w klasie Intent, która określa rodzaj operacji, jaką chcesz wykonać.

• Mówi systemowi „co chcesz zrobić” — np. wyświetlić stronę, edytować kontakt, zadzwonić, wysłać plik.
• Jest zawsze częścią Intentu, np. Intent.ACTION_VIEW, Intent.ACTION_EDIT, Intent.ACTION_DIAL.
• Android używa jej, żeby wybrać odpowiednią aplikację lub komponent, który potrafi obsłużyć daną akcję.

Niejawna intencja zwykle zawiera:

1. Akcję (Action) — co ma być wykonane
2. Dane (Data) — nad czym ma być wykonane
3. (opcjonalnie) Typ danych (MIME type) — np. "image/png", "text/plain"

Najczęściej używane akcje systemowe:

Akcja	Typ		Przykład
ACTION_VIEW		Otwórz dane / aplikację	przeglądarka, mapy, galeria
ACTION_EDIT		Edytuj dane	kontakt, zdjęcie
ACTION_DIAL		Otwórz dialer	numer telefonu
ACTION_CALL		Zadzwoń (z pozwoleniem)	numer telefonu
ACTION_SEND		Udostępnij dane	tekst, obraz
ACTION_PICK		Wybierz dane	kontakt, zdjęcie
ACTION_GET_CONTENT		Wybierz plik z pamięci	galeria, dokumenty
ACTION_INSERT		Dodaj nowy element	kontakt, wydarzenie
ACTION_MAIN		Główna aktywność aplikacji	ekran startowy

Uruchamiając aktywność poprzez intencje, jak w przykładzie poniżej Android pokaże listę wszystkich aplikacji, które potrafią obsłużyć akcję SEND z danym typem danych (text/plain): Gmail, Messenger, SMS, Bluetooth, WhatsApp, Notatki itp.

Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, "Cześć, to wiadomość!");
startActivity(Intent.createChooser(intent, "Udostępnij przez:"));

--------------------------------------------------------------------------------------------------------------------

ü Możemy definiować własne akcje (sposób deklaracji opisany poniżej w części filtrów):

<action android:name="com.example.nazwaaplikacji.SHOW_NUMBER" />

To Twoja własna akcja, zdefiniowana tylko w Twojej aplikacji.
Nie jest znana systemowi Android ani innym aplikacjom, dopóki nie dodasz jej do swojego AndroidManifest.xml.

NUMBER niestandardowa akcja - działa tylko między aplikacjami, które Ty sam zaprojektujesz, służy np. do komunikacji wewnętrznej lub specyficznej integracji.

Intent intent = new Intent("com.example.nazwaaplikacji.SHOW_NUMBER");

Najczęściej używane typy MIME

Typ danych	MIME type	Przykład użycia
Zwykły tekst	"text/plain"	wiadomość, notatka, link
Obraz	"image/*" lub "image/jpeg"	zdjęcie z aparatu
Wideo	"video/*"	film z galerii
Audio	"audio/*"	plik MP3
Plik dowolny	"*/*"	pozwala użytkownikowi wybrać dowolny typ
PDF	"application/pdf"	dokument PDF
HTML	"text/html"	zawartość stron WWW

Metoda setType() ustawia MIME type, czyli tzw. typ zawartości (Content Type) — używany przez Androida (i Internet ogólnie) do określenia rodzaju danych.

Przykład 1 — otwieranie strony WWW

Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("https://www.google.com"));
startActivity(intent);

Android znajdzie aplikację (np. Chrome, Firefox), która potrafi „wyświetlić” (ACTION_VIEW) adres URL.
Użytkownik może zostać zapytany, którą aplikacją chce to otworzyć (tzw. „chooser”).

Przykład 2 — wykonanie połączenia telefonicznego

Intent intent = new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:123456789"));
startActivity(intent);

Otwiera aplikację telefonu z gotowym numerem, ale bez automatycznego dzwonienia (bez uprawnień CALL_PHONE).

Przykład 3 — wysłanie e-maila

Intent intent = new Intent(Intent.ACTION_SEND);
intent.setType("message/rfc822"); // typ MIME dla e-maili
intent.putExtra(Intent.EXTRA_EMAIL, new String[]{"kontakt@example.com"});
intent.putExtra(Intent.EXTRA_SUBJECT, "Temat wiadomości");
intent.putExtra(Intent.EXTRA_TEXT, "Treść wiadomości...");
startActivity(Intent.createChooser(intent, "Wybierz aplikację e-mail"));

Android wyświetli listę aplikacji obsługujących e-maile (np. Gmail, Outlook).

Metoda putExtra() służy do dołączania dodatkowych danych (np. tekstu, liczb, adresów, obiektów) do obiektu Intent.
Działa jak „plecak” z informacjami, które przenosisz między ekranami (Activity) lub aplikacjami.

Intent.EXTRA_TEXT - to stała (konstanta) zdefiniowana w klasie Intent, która ma wartość:
public static final String EXTRA_TEXT = "android.intent.extra.TEXT";

Czyli to po prostu standardowy klucz, którego Android i inne aplikacje używają do rozpoznawania tekstu przesyłanego w Intent.

Przykład 4 — udostępnianie tekstu

Intent shareIntent = new Intent(Intent.ACTION_SEND);
shareIntent.setType("text/plain");
shareIntent.putExtra(Intent.EXTRA_TEXT, "To jest treść do udostępnienia");
startActivity(Intent.createChooser(shareIntent, "Udostępnij przez"));

System pokaże listę aplikacji (np. Messenger, WhatsApp, Twitter), które mogą przyjąć tekst.

Przykład 5 — otwarcie mapy z konkretnymi współrzędnymi

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("geo:50.123,7.1434?z=19"));
startActivity(intent);

Otworzy aplikację mapową (np. Google Maps) i pokaże dokładnie wskazaną lokalizację z określonym zoomem.

• Intent.ACTION_VIEW oznacza, że chcesz wyświetlić coś (tu: lokalizację).
• Uri.parse("geo:50.123,7.1434?z=19") to adres URI w formacie geo:latitude,longitude.

· 50.123 - szerokość geograficzna (latitude)

· 7.1434 - długość geograficzna (longitude)

· z=19 - poziom przybliżenia (zoom), gdzie:

o 1 = cały świat

o 20 = bardzo blisko (ulica / budynek)

Przykład 6 — wyszukiwanie miejsca po nazwie

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("geo:0,0?q=PANS Krosno"));
startActivity(intent);

Otworzy aplikację mapową (np. Google Maps) i wyszuka podaną lokalizację po nazwie.
Jeśli miejsce istnieje w Google Maps — pokaże jego dokładny punkt na mapie.

• geo:0,0 - używane, gdy nie podajesz konkretnych współrzędnych.
• q=PANS Krosno - zapytanie wyszukiwania (q = query), czyli szukaj miejsca o nazwie „PANS Krosno”.

Możesz też łączyć oba podejścia. Otworzy mapę w danym miejscu i zaznaczy „Restauracja Roma” jako punkt.

Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("geo:50.123,7.1434?q=Restauracja+Roma"));
startActivity(intent);

Przykład 7 - edycja kontaktu

Intent intent = new Intent(Intent.ACTION_EDIT);
intent.setDataAndType(uri, mimeType);
startActivity(intent);

To niejawna intencja, więc Android sam wybiera aplikację, która potrafi dany typ danych otworzyć w trybie edycji.

· uri - adres zasobu, który chcesz edytować (np. Uri pliku, kontaktu, zdjęcia itp.)

· mimeType - typ danych, np. "image/*", "text/plain", "vnd.android.cursor.item/contact"

·

Intent.ACTION_EDIT informuje system, że chcesz edytować określony zasób (np. plik, kontakt, zdjęcie).

Intent intent = new Intent(Intent.ACTION_EDIT);
intent.setData(Uri.parse("content://contacts/people/1")); // ID kontaktu = 1
startActivity(intent);

Otworzy aplikację „Kontakty” z formularzem edycji wskazanego kontaktu.

Przykład 8 - edycja pliku tekstowego

Uri uri = Uri.parse("file:///storage/emulated/0/Documents/notatka.txt");
Intent intent = new Intent(Intent.ACTION_EDIT);
intent.setDataAndType(uri, "text/plain");
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivity(intent);

Android otworzy aplikację, która potrafi edytować pliki tekstowe (np. notatnik).

Uwaga: od Androida 7 (Nougat) nie można używać ścieżek file:// bezpośrednio - trzeba korzystać z FileProvider i content://.

Przykład 9 - edycja notatki (tekst jako dane)

Intent intent = new Intent(Intent.ACTION_EDIT);
intent.setType("text/plain");
intent.putExtra(Intent.EXTRA_TEXT, "To jest tekst do edycji");
startActivity(Intent.createChooser(intent, "Wybierz aplikację do edycji"));

Jeśli masz dane tekstowe, które chcesz przekazać do aplikacji do edycji (np. aplikacji notatnika)

Android zapyta, jaką aplikacją otworzyć tekst — użytkownik może wybrać np. Keep, Notatnik, Gmail itd.

Przykład 10 - edycja zdjęcia (np. w aplikacji Galeria)

Uri imageUri = Uri.parse("content://media/external/images/media/45");
Intent intent = new Intent(Intent.ACTION_EDIT);
intent.setDataAndType(imageUri, "image/*");
intent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
startActivity(Intent.createChooser(intent, "Wybierz edytor zdjęć"));

Otworzy aplikację (np. Galerię lub Photoshop Express) w trybie edycji obrazu.

ü Wybór aplikacji

Zawsze używaj Intent.createChooser(), aby użytkownik mógł wybrać aplikację:

startActivity(Intent.createChooser(intent, "Wybierz aplikację"));

ü Filtry - Wybieranie aplikacji przez Android

System używa filtrów intencji (<intent-filter>) zdefiniowanych w plikach AndroidManifest.xml wszystkich aplikacji.

Każdy komponent (np. Activity) może zadeklarować, jakie akcje i dane potrafi obsłużyć.

Przykład filtra intencji w manifestcie:

<activity android:name=".DisplayMessageActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<data android:mimeType="text/plain" />
</intent-filter>
</activity>

Atrybut android:exported to bardzo ważny element w AndroidManifest.xml, który określa, czy komponent aplikacji (np. Activity, Service, Receiver) może być uruchamiany przez inne aplikacje.

<activity
android:name=".MainActivity2"
android:exported="false" />
<activity

android:exported="false" oznacza, że:

• ta aktywność (lub inny komponent) nie może być uruchomiona spoza aplikacji,
• może być uruchamiana tylko wewnętrznie, przez Intenty pochodzące z tej samej aplikacji.

Od Androida 12 (API 31) ten atrybut jest wymagany dla wszystkich komponentów (Activity, Service, Receiver), które mają intent-filter — w przeciwnym razie aplikacja się nie zbuduje.

<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>

<activity
android:name=".HiddenActivity"
android:exported="false" />

android.intent.action.MAIN mówi systemowi Android „To jest główna akcja aplikacji — uruchom ją jako pierwszą, gdy użytkownik włącza aplikację z listy.”

android.intent.category.LAUNCHER mówi „Pokaż ikonę tej aktywności w launcherze (czyli na ekranie głównym, wśród innych aplikacji).”

Przykład pełnego intent-filter z data

<activity android:name=".WebViewActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="https" android:host="www.mojastrona.pl" />
</intent-filter>
</activity>

Ten zapis mówi Androidowi „Jeśli użytkownik kliknie link HTTPS prowadzący do www.mojastrona.pl, zaproponuj otwarcie go w mojej aplikacji (w aktywności WebViewActivity).”

Po zainstalowaniu aplikacji, jeśli użytkownik kliknie np.:

s

Android zapyta:

„Czy chcesz otworzyć ten link w przeglądarce, czy w aplikacji TwojejNazwaAppki?”

A jeśli użytkownik wybierze Twoją aplikację i zaznaczy Zawsze, to wszystkie takie linki będą otwierane odtąd w niej.

Schemat (android:scheme)	Co obsługuje	Przykład linku
https	Strony internetowe	https://example.com
http	Strony internetowe (bez HTTPS)	http://example.com
geo	Lokalizacje GPS	geo:52.2297,21.0122
tel	Numery telefonów	tel:123456789
mailto	Adresy e-mail	mailto:kontakt@example.com
content	Dostęp do plików przez ContentProvider	content://media/external/images/media/5
file	Lokalne pliki	file:///sdcard/plik.txt

ü Kategorie (Categories)

Kategorie (<category>) określają rodzaj kontekstu lub przeznaczenie aktywności, czyli w jakich sytuacjach system Android może ją uruchomić.

Oprócz akcji i danych, intencja może mieć kategorię, która określa kontekst, w jakim akcja ma być wykonana.

Najczęściej używane:

Kategoria	Znaczenie
Intent.CATEGORY_DEFAULT	Domyślna — wymagana przy większości intencji
Intent.CATEGORY_BROWSABLE	Pozwala otworzyć aktywność z przeglądarki lub z linku
Intent.CATEGORY_LAUNCHER	Używana dla głównej aktywności aplikacji

<category android:name="android.intent.category.DEFAULT" /> oznacza, że aktywność może być uruchomiona przez „zwykły” (domyślny) Intent, wysłany z kodu aplikacji metodą startActivity(intent), czyli taki, który nie ma jawnie określonej kategorii.

Przykład z kategorią BROWSABLE (deep link)

<activity android:name=".WebViewActivity">
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data android:scheme="https" android:host="www.mojastrona.pl" />
</intent-filter>
</activity>

Teraz, gdy ktoś kliknie w link https://www.mojastrona.pl — Android zaproponuje otwarcie Twojej aplikacji.

ü Pozwolenia (Permissions)

Pozwolenia w Androidzie to mechanizm ochrony prywatności i bezpieczeństwa użytkownika.
Każda aplikacja, która chce uzyskać dostęp do wrażliwych danych lub funkcji systemowych, musi najpierw poprosić o zgodę użytkownika.

Dwa główne typy pozwoleń:

Normal permissions

• Dotyczą czynności o niskim ryzyku (np. dostęp do Internetu).
• Są automatycznie przyznawane po instalacji aplikacji.

Przykład:

<uses-permission android:name="android.permission.INTERNET" />

Dangerous permissions

• Dotyczą dostępu do prywatnych danych użytkownika lub sprzętu (np. lokalizacja, kamera, kontakty).
• Wymagają potwierdzenia przez użytkownika w czasie działania aplikacji (runtime permission).

Przykład:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Android chroni użytkownika przed nadużyciami — np. aplikacja nie może:

· wykonywać połączeń bez zgody,

· śledzić lokalizacji bez zgody,

· wysyłać wiadomości SMS bez zgody.

Dzięki temu użytkownik ma kontrolę nad tym, do czego aplikacja ma dostęp.

Przykład

Jeśli chciałbyś wykonać połączenie automatycznie:

Intent intent = new Intent(Intent.ACTION_CALL, Uri.parse("tel:123456789"));
startActivity(intent);

Tutaj aplikacja wykonuje połączenie bez udziału użytkownika, więc wymagane jest:

<uses-feature
android:name="android.hardware.telephony"
android:required="false" />
<uses-permission android:name="android.permission.CALL_PHONE" />

I dodatkowo musisz poprosić użytkownika o zgodę w czasie działania aplikacji (runtime):

// ------------------------------w onCreate ----------------------------------------
Intent callIntent = new Intent(Intent.ACTION_CALL);
callIntent.setData(Uri.parse("tel:123456789"));

ActivityResultLauncher<String> requestPermissionLauncher =
registerForActivityResult(new ActivityResultContracts.RequestPermission(), isGranted -> {
if (isGranted) {
// Pozwolenie przyznane - wykonaj akcję raz po zezwoleniu
startActivity(callIntent);
} else {
Toast.makeText(this, "Brak pozwolenia na wykonanie połączenia", Toast.LENGTH_SHORT).show();
}
});
//--------------------------------------------------------------------------------------
binding.button.setOnClickListener(v -> {
if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED) {
// Pozwolenie przyznane wcześniej - wykonaj akcję przy kolejnych kliknięciach
startActivity(callIntent);
} else {
requestPermissionLauncher.launch(Manifest.permission.CALL_PHONE);
}
});

Pozwolenia lokalizacyjne (jeśli chcesz użyć GPS w aplikacji)

Jeśli Twoja aplikacja chciałaby sama pobierać pozycję użytkownika (a nie tylko otwierać mapę),
wtedy musisz dodać jedno z tych pozwoleń:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Pozostałe pozwolenia: https://developer.android.com/reference/android/Manifest.permission

ü Funkcjonalność <uses-feature>

Tag <uses-feature> w Androidzie jest często mylony z <uses-permission>, ale jego rola jest inna.
<uses-feature> to deklaracja w pliku AndroidManifest.xml, która informuje system Android oraz Sklep Google Play,
że Twoja aplikacja wymaga lub opcjonalnie korzysta z określonych funkcji sprzętowych lub programowych urządzenia.

<uses-permission> mówi „chcę mieć dostęp do…” (np. do kamery, internetu, kontaktów)
<uses-feature> mówi „moja aplikacja potrzebuje sprzętu lub funkcji…” (np. kamery, GPS, Bluetooth)

Przykład 1 - aplikacja wymaga kamery

<uses-feature android:name="android.hardware.camera" android:required="true" />

Twoja aplikacja nie uruchomi się na urządzeniu bez kamery.

W Google Play takie urządzenia nie zobaczą Twojej aplikacji (zostanie odfiltrowana).

Inne przykłady:

Przykład 2 - kamera jest tylko opcjonalna

<uses-feature android:name="android.hardware.camera" android:required="false" />

Twoja aplikacja może działać bez kamery, ale jeśli jest — to ją wykorzysta.

Google Play nie blokuje instalacji na urządzeniach bez kamery.

Przykład 3 — GPS (lokalizacja)

<uses-feature android:name="android.hardware.location.gps" android:required="true" />

Aplikacja wymaga sprzętowego GPS, np. aplikacja nawigacyjna.
Bez GPS nie będzie działać więc nie pojawi się w Sklepie Play na urządzeniach bez tej funkcji.

Przykład 4 — Bluetooth

<uses-feature android:name="android.hardware.bluetooth" android:required="false" />

Aplikacja może korzystać z Bluetooth, ale nie jest to wymagane.

--------------------------------------------------------------------------------------------------------------------------

ü Przykład użycia intencji do uruchomienia innej aktywności w sposób niejawny

----- Aplikacja 1 -----

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/main"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">

<LinearLayout
android:orientation="vertical"
android:gravity="center"
android:padding="20dp"
android:layout_width="match_parent"
android:layout_height="match_parent">

<EditText
android:id="@+id/editTextMessage"
android:hint="Wpisz wiadomość"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:inputType="text" />

<Button
android:id="@+id/btnSend"
android:text="Wyślij wiadomość"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginTop="20dp"/>
</LinearLayout>

</LinearLayout>

MainActivity.java

package com.example.ap1;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

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

EditText editTextMessage = findViewById(R.id.editTextMessage);
Button btnSend = findViewById(R.id.btnSend);

btnSend.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String message = editTextMessage.getText().toString();

// Tworzymy NIEJAWNY Intent z akcją systemową SEND
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, message);
sendIntent.setType("text/plain");

// Pokazujemy użytkownikowi listę aplikacji, które mogą to obsłużyć
Intent shareIntent = Intent.createChooser(sendIntent, "Wybierz aplikację do wysłania");
startActivity(shareIntent);
}
});
}
}

----- Aplikacja 2 -----

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/main"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:gravity="center"
android:background="#C59147"
tools:context=".MainActivity">

<TextView
android:id="@+id/textViewReceived"
android:text="Brak wiadomości"
android:textSize="24sp"
android:textColor="#000"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</LinearLayout>

MainActivity.java

package com.example.ap2;

import android.content.Intent;
import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

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

TextView textView = findViewById(R.id.textViewReceived);
Intent intent = getIntent();

// Sprawdzamy, czy aplikacja została uruchomiona z akcją SEND
if (Intent.ACTION_SEND.equals(intent.getAction()) && intent.getType() != null) {
if ("text/plain".equals(intent.getType())) {
String receivedText = intent.getStringExtra(Intent.EXTRA_TEXT);
if (receivedText != null) {
textView.setText("Odebrano: " + receivedText);
}
}
}
}
}

AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">

<application
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.Ap2">
<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />

<!-- 🔹 Obsługuje akcję SEND -->
<action android:name="android.intent.action.SEND" />
<!-- 🔹 Kategoria dla intentów z innych aplikacji -->
<category android:name="android.intent.category.DEFAULT" />
<!-- 🔹 Określamy, że ta aktywność przyjmuje dane tekstowe -->
<data android:mimeType="text/plain" />

</intent-filter>
</activity>
</application>

</manifest>

----------------------------------------------------------------------------------------------------------

4. Zadania

Zadanie 1

Przetestuj wszystkie przykłady opisujące akcje pozwalające uruchamiać aktywności innych aplikacji opisane na początku instrukcji.

Pamiętaj o dodaniu odpowiednich pozwoleń w pliku AndroidManifest.xml

Zadanie 2.

Napisz dwie aplikacje mobilne:

1. AppSender — wysyła dane (np. liczbę całkowitą) za pomocą niejawnego Intentu.
2. AppReceiver — odbiera dane z Intentu i wyświetla wynik (np. podwojoną wartość liczby).

Użyj niejawnego Intent (czyli bez podawania nazwy klasy, tylko akcji).
Uwzględnij wymagane pozwolenia i filtry w manifestach.

Użyj własnej akcji a nie systemowej. To oznacza że tylko nasza pierwsza aplikacją będzie mogła uruchamiać naszą drugą (bez obcych aplikacji)

Zadanie 3

Przetestuj aplikację z powyższego przykładu modyfikując jej funkcje tak aby używała jednej z akcji opisanych na początku instrukcji,