Arkusz egzaminacyjny INF.04. Styczeń 2023

Część 1. Aplikacja konsolowa: Program do obsługi notatek

Napisz program implementujący klasę do obsługi notatek.

Założenia do programu:

• Program wykonywany w konsoli
• Obiektowy język programowania zgodny z zainstalowanym na stanowisku egzaminacyjnym: C++ lub C#, lub Java, lub Python
• Klasa notatka zawiera pola:
• statyczne numeryczne licznika notatek do zliczania utworzonych notatek
• numeryczne do zapisu unikalnego identyfikatora
• dwa tekstowe do zapisu tytułu notatki i treści notatki
• Dostęp do wszystkich pól jest ograniczony do wnętrza klasy notatka, przy czym pola identyfikatora i licznika nie są dostępne dla klas potomnych, a pola tekstowe są dostępne dla klas potomnych
• Klasa notatka zawiera jeden konstruktor o parametrach wejściowych dla tytułu i treści. Ma on za zadanie kolejno:
• inkrementować licznik notatek
• ustawić pole identyfikatora równe licznikowi notatek, czyli pierwsza utworzona notatka ma id równe 1, druga ? 2, itd.
• ustawić pola tytułu i treści równe parametrom
• Klasa notatka zawiera dwie metody bezparametrowe i niezwracające wartości, które mogą być wołane w programie głównym:
• metodę wyświetlenia tytułu i treści notatki
• metodę diagnostyczną wypisującą zawartości wszystkich pól oddzielone od siebie średnikami
• Program powinien podejmować jasną komunikację z użytkownikiem, wyświetlane informacje powinny być zrozumiałe
• Program powinien być zapisany czytelnie, z zachowaniem zasad czystego formatowania kodu, należy stosować znaczące nazwy zmiennych i funkcji. Wielkość liter np. dla nazwy klasy może być realizowana zgodnie z przyjętą konwencją nazewnictwa w danym języku programowania
• Program główny powinien zawierać test działania aplikacji polegający na utworzeniu dwóch notatek z dowolnymi (znaczącymi) danymi (źródło danych jest dowolne: stała napisowa, literał lub pobrane z klawiatury) oraz uruchomieniu dla każdej z nich obu metod
• Dokumentację aplikacji należy utworzyć zgodnie z opisem w części III treści zadania.

Kod aplikacji przygotuj do nagrania na płytę. W podfolderze konsola powinno znaleźć się archiwum całego projektu o nazwie konsola.zip, plik z kodem źródłowym programu oraz plik uruchomieniowy, jeżeli istnieje.

PRZEJDŹ DO ROZWIĄZANIA

Część 2. Aplikacja mobilna: Proste notatki

Wykonaj aplikację mobilną obsługującą proste notatki tekstowe za pomocą środowiska programistycznego dostępnego na stanowisku egzaminacyjnym oraz uruchom ją w dostępnym emulatorze systemu mobilnego. Aplikacja umożliwia wpisywanie prostych notatek. Dane początkowe aplikacji zapisano w pliku dane.txt, zawartym w archiwum zad2.zip, które znajduje się na pulpicie konta Egzamin i jest zabezpieczony hasłem: !D@Ne$

Na obrazach 1a i 1b przedstawiono stan początkowy aplikacji mobilnej. W zależności od zastosowanego środowiska programistycznego oraz emulowanego systemu wynik końcowy może nieznacznie się różnić od przedstawionego. Obraz 2 przedstawia zachowanie aplikacji, dodano notatkę ?Urodziny Ali?, jest ona widoczna jako ostatni element listy.

Elementy aplikacji:

• Pole edycyjne z podpowiedzią Nowy element.
• Przycisk o treści: DODAJ.
• Lista (element widoku listy).
• Rozmieszczenie elementów zgodne z obrazami 1a i 1b

Działanie aplikacji:

• W stanie początkowym wyświetlone są 3 notatki. Treść notatek można skopiować z pliku dane.txt lub ręcznie wpisać do kodu źródłowego z obrazu 1b
• Po wpisaniu do pola edycyjnego treści i wybraniu przycisku, jest ona zapisywana jako ostatni element widoku listy (obraz 2)

Założenia aplikacji:

• Interfejs użytkownika zapisany za pomocą języka znaczników wspieranego w danym środowisku (np. XAML, XML).
• Zastosowany rozkład liniowy wertykalny (Linear / Stack lub inny o tej idei) z zagłębionym rozkładem liniowym horyzontalnym dla pola edycyjnego i przycisku.
• Cechy przycisku: Kolor tła Crimson (#DC143C), biały kolor czcionki, zgodnie z Obrazem 1a.
• Cechy elementów listy: domyślny kolor czcionki, kolor separatora: Crimson, separator jest widoczny (np. poprzez ustawienie wysokości separatora)
• Notatki są zapisane w dowolnej kolekcji z elementami typu napisowego połączonej z widokiem listy jako jej źródło danych
• Wybranie przycisku powoduje dopisanie do kolekcji treści z pola edycyjnego, widok listy jest automatycznie odświeżany. Dla uproszczenia można założyć, że pole jest zawsze wypełnione, jeśli wybrany jest przycisk
• Aplikacja powinna być zapisana czytelnie, z zachowaniem zasad czystego formatowania kodu, należy stosować znaczące nazwy zmiennych i funkcji.

Podejmij próbę kompilacji i uruchomienia aplikacji. Informacje dotyczące dokumentacji i zrzutu ekranowego umieszczono w części III zadania. Kod aplikacji przygotuj do nagrania na płytę. W podfolderze mobilna powinno znaleźć się archiwum całego projektu o nazwie mobilna.zip, plik z kodem źródłowym interfejsu użytkownika (XAML lub XML) oraz plik źródłowy kodu skojarzonego z interfejsem użytkownika.

PRZEJDŹ DO ROZWIĄZANIA

Część III. Dokumentacja utworzonych aplikacji

Wykonaj dokumentację do aplikacji utworzonych na egzaminie. W kodzie źródłowym aplikacji konsolowej utwórz nagłówek klasy, według wzoru. Nagłówek powinien znaleźć się nad definicją klasy. W miejscu nawiasów <> należy podać odpowiednie opisy. W miejscu autor należy podać numer zdającego.

UWAGA: Dokumentację umieścić w komentarzu (wieloliniowym lub kilku jednoliniowych). Znajdujący się w listingu 1 wzór dokumentacji jest bez znaków początku i końca komentarza, gdyż te są różne dla różnych języków programowania

Wykonaj zrzuty ekranu dokumentujące uruchomienie aplikacji utworzonych podczas egzaminu. Zrzuty powinny obejmować cały obszar ekranu monitora z widocznym paskiem zadań. Jeżeli aplikacja uruchamia się, na zrzucie należy umieścić okno z wynikiem działania programu oraz otwarte środowisko programistyczne z projektem lub okno terminala z kompilacją projektu. Jeżeli aplikacja nie uruchamia się z powodu błędów kompilacji, należy na zrzucie umieścić okno ze spisem błędów i widocznym otwartym środowiskiem programistycznym. Wykonać należy co najmniej tyle zrzutów, ile interakcji podejmuje aplikacja.

Wymagane zrzuty ekranu:

• Aplikacja konsolowa ? zrzuty nazwane: konsola1, konsola2 ...
• Aplikacja mobilna ? zrzuty nazwane: mobile1, mobile2 ... (np. stan początkowy, w trakcie pisania, po dodaniu elementu)

W edytorze tekstu pakietu biurowego utwórz plik z dokumentacją i nazwij go egzamin. Dokument powinien zawierać zrzuty ekranu oraz informacje:

• Nazwę systemu operacyjnego, na którym pracował zdający,
• Nazwy środowisk programistycznych, z których zdający korzystał na egzaminie,
• Nazwę emulatora dla aplikacji mobilnej,
• Nazwy języków programowania,
• Opcjonalnie komentarz do wykonanej pracy.

Zrzuty ekranu i dokument umieść w podfolderze dokumentacja.

UWAGA: Nagraj płytę z rezultatami pracy. W folderze z numerem zdającego powinny się znajdować podfoldery: konsola, mobilna, dokumentacja. W folderze dokumentacja: pliki ze zrzutami oraz plik egzamin. W folderze konsola: spakowany cały projekt aplikacji konsolowej, pliki źródłowe, opcjonalnie plik uruchomieniowy. W folderze mobilna: spakowany cały projekt aplikacji mobilnej, pliki z kodem źródłowym interfejsu i logiki. Po nagraniu płyty sprawdź poprawność nagrania. Opisz płytę numerem zdającego i pozostaw na stanowisku, zapakowaną w pudełku wraz z arkuszem egzaminacyjnym.

Rozwiązanie części I: Aplikacja konsolowa

Przygotowanie rozwiązani rozpoczniemy od wybrania w kompilatorze Visual Studio modułu kompilacji dla Aplikacja konsoli (.NET Framework)

Dodajemy klasę

Do projektu dodajemy klasę związaną z tworzeniem notatek. Dla klasy przyjmujemy nazwę (pisaną z dużej litery) Notatka

W oknie dialogowym tworzenia klasy wpisz jak poniżej

W utworzonym pliku klasy Notatka.cs definiujemy pola prywatne i publiczne zgodnie z wymaganiami arkusz egzaminacyjnego

internal class Notatka
{
    private static int licznik=0;
    private int id;
    public string tytul;
    public string tresc;
}

Dodajemy konstruktor klasy Notatka

W wymaganiach arkusza podano, że konstruktor zawiera dwa parametry dla tytułu i treści notatki. Konstruktor ma inkrementować (zwiększać o jeden) licznik notatek, przypisać identyfikator notatce, tytuł i treść.

public Notatka(string _tytul,string _tresc) {
    licznik++;
    id = licznik;
    tytul = _tytul;
    tresc = _tresc;
}

Każde użycie konstruktora zwiększa licznik, a bieżący stan licznika jest przypisywany do identyfikatora tworzonej notatki.

Funkcja diagnostyczna i pokazująca zawartość notatki

Do klasy Notatka dopisujemy dwie proste w działaniu funkcje. Jedna z nich jest funkcja diagnostyczną wypisująca wszystkie parametry notatki, a druga jest funkcja pokazująca zawartość konkretnej notatki. W obu funkcjach zastosujemy łańcuch formatujący- String.Format

public void Diagnostyka()
{
    Console.WriteLine(String.Format(
                        "Licznik: {0}, id: {1}, Tytuł: {2}, Treść: {3}",
                        licznik,id,tytul,tresc));
}

W funkcji pokazującej zawartość danych w łańcuchu formatującym zastosujemy przeniesieni do nowego wiersza i uzycie tabulatora (sekwencja parametrów \n\t)

public void PokazNotatke()
{
    Console.WriteLine(String.Format(
                        "Tytuł: {0}\n\tTreść: {1}",
                        tytul, tresc));
}

Definiujemy zmienne

W głównym pliku projektu (standardowo Program.cs) definiujemy trzy zmienne oparte na klasie Notatka. W treści zadania nie jest narzucony sposób podania treści notatek. Zastosujemy najprostszą metodę. Treści podamy na sztywno w kodzie programu w momencie tworzenia zmiennych opartych na klasie Notatka.

static void Main(string[] args)
{
    Notatka notatka_1,notatka_2,notatka_3;
    notatka_1 = new Notatka("Informacja dnia",
	"UWAGA! W dniu dzisiejszym rozpoczynają się egzaminy");
    notatka_2 = new Notatka("Egzamin trwa",
	"Uczniowie 4 klasy technikum o kierunku technik programista");
    notatka_3 = new Notatka("Wyniki egzaminu",
	"W najblizszych dniach CKE opublikuje wyniki egzaminu");
    Console.WriteLine("Pokaż NOTATKI");
    notatka_1.PokazNotatke();
    notatka_2.PokazNotatke();
    notatka_3.PokazNotatke();
    Console.WriteLine("Pokaż DIAGNOSTYKĘ");
    notatka_1.Diagnostyka();
    notatka_2.Diagnostyka();
    notatka_3.Diagnostyka();
    Console.ReadKey();
}

Skompiluj program i sprawdź zachowanie utworzonej aplikacji konsolowej.

Pełny kod rozwiązania

Plik klasy Notatka (Notatka.cs)

using System;

namespace styczen_2023_v2_problem_1_notatka
{
    internal class Notatka
    {
        private static int licznik=0;
        private int id;
        public string tytul;
        public string tresc;

        public Notatka(string _tytul,string _tresc) {
            licznik++;
            id = licznik;
            tytul = _tytul;
            tresc = _tresc;
        }
        public void Diagnostyka()
        {
            Console.WriteLine(String.Format(
                              "Licznik: {0}, id: {1}, Tytuł: {2}, Treść: {3}",
                              licznik,id,tytul,tresc));
        }
        public void PokazNotatke()
        {
            Console.WriteLine(String.Format(
                              "Tytuł: {0}\n\tTreść: {1}",
                              tytul, tresc));
        }
    }
}

Plik główny aplikacji konsolowej (Program.cs)

using System;

namespace styczen_2023_v2_problem_1_notatka
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Notatka notatka_1,notatka_2,notatka_3;
            notatka_1 = new Notatka("Informacja dnia",
			"UWAGA! W dniu dzisiejszym rozpoczynają się egzaminy");
            notatka_2 = new Notatka("Egzamin trwa",
			"Uczniowie 4 klasy technikum o kierunku technik programista");
            notatka_3 = new Notatka("Wyniki egzaminu",
			"W najblizszych dniach CKE opublikuje wyniki egzaminu");
            Console.WriteLine("Pokaż NOTATKI");
            notatka_1.PokazNotatke();
            notatka_2.PokazNotatke();
            notatka_3.PokazNotatke();
            Console.WriteLine("Pokaż DIAGNOSTYKĘ");
            notatka_1.Diagnostyka();
            notatka_2.Diagnostyka();
            notatka_3.Diagnostyka();
            Console.ReadKey();
        }
    }
}

Kod rozwiązania

pobierz

Rozwiązanie części II. Aplikacja mobilna: Proste notatki tekstowe

UWAGA. Do rozwiązania użyto języka Kotlin.

Inicjujemy pusty projekt

Otwieramy kompilator Android Studio i wybieramy New Project/ Empty Views Activity. Wybór zatwierdzamy klawiszem Next.

Ustalamy nazwę projektu aplikacji, folder lokalizacji projektu i wybieramy język. Omawiane rozwiązanie jest pisane w Kotlinie, stąd wybierz jak poniżej.

Projekt jest gotowy do wprowadzania kodu, ale zanim zaczniesz kodować przygotuj wirtualny emulator urządzenia mobilnego.

Przygotowujemy emulator urządzenia mobilnego.

Zauważ ,że w arkuszu egzaminacyjnym przegotowanym przez CKE jedna z ilustracji przedstawia działanie aplikacji na urządzeniu Nexus 5X API 29 x86. Jeżeli taki emulator istnieje w twoim kompilatorze to go uruchom. Jeżeli nie, to nie próbuj instalować urządzenia emulatora- masz odcięty Internet. Wybierz dowolny emulator z API 29 lub nowszym API (wyższy numer).

Jeżeli nie masz przygotowanego emulatora urządzenia mobilenego i nie wiesz jak to zrobić, to przejdź do tej instrukcji: Jak zainstalować emulator ?

Tworzymy układ widoku głównej aktywności aplikacji

Podane w arkuszu egzaminacyjnym wymagania dla układu widoku okna aplikacji narzucają zastosowanie układu LinearLayout (vertical). Dodajemy ten układ i przypisujemy margines układu na 8 dp dla każdego boku

W pliku XML (activity_main.xml) układu widoku zapisane zostaną poniższe parametry

<LinearLayout
    android:layout_width="0dp"
    android:layout_height="0dp"
    android:layout_marginStart="8dp"
    android:layout_marginTop="8dp"
    android:layout_marginEnd="8dp"
    android:layout_marginBottom="8dp"
    android:orientation="vertical"
    app:layout_constraintBottom_toBottomOf="parent"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintHorizontal_bias="1.0"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent"
    app:layout_constraintVertical_bias="1.0">
</LinearLayout>

Pole do wprowadzania danych

Kontrolki EditText oraz Button służące do wprowadzenia nowych danych i ich zaakceptowania ułożone są horyzontalnie- jedna obok drugiej . Te kontrolki umieszczamy w obszarze kontrolki LinearLayout (horizontal). Dodajemy je do układu projektu widoku, co utworzy poniższą hierarchię.

Nowym kontrolkom odpowiednio przypisz parametry. Poniżej aktualna zawartość pliku XML tworzonego układu widoku.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    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:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="1.0"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="1.0">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">

            <EditText
                android:id="@+id/editText1"
                android:layout_width="300dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="Nowy element"
                android:textSize="24sp" />

            <Button
                android:id="@+id/button1"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:backgroundTint="#DC143C"
                android:text="DODAJ" />
        </LinearLayout>
    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

Lista notatek

Ostatnia wymagana kontrolka to ListView. W stanie początkowym lista powinna zawierać trzy elementy. Każdy element ma wpisany krótki tekst. Zaczniemy od osadzenia kontrolki ListView. Osadzonej kontrolce przypisz layout_width i layout_height na match_parent. Wprowadź identyfikator na id: ListView1

W warunkach zadania podano, że kolor linii separatora jest ustawiony na Crimson (#DC143C). Aby zmiany koloru były widoczne, trzeba również zmienić szerokość linii separatora. Przejdź do pliku XML i ustaw jak poniżej:

<ListView
    android:id="@+id/ListView1"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:drawSelectorOnTop="false"
    android:divider="#DC143C"
    android:dividerHeight="4px"/>

Zmiany prezentują się jak poniżej

Kolekcja notatek

Warunki zadania podają, że notatki zapisane są w dowolnej kolekcji. Utworzymy zalążek takiej kolekcji. Początkową treść skopiujemy z dołączonego widoku w arkuszu egzaminacyjnym do dynamicznej listy typu String. Zastosowanie zmiennej listy upraszcza proces odświeżania widoku kontrolki ListView po dodaniu elementu.

Przechodzimy do pliku MainActivity.kt i deklarujemy zmienną listę typu łańcuchowego (String) z przypisanym początkowym tekstem

var itemyTresci= arrayListOf<String>(
    "Zakupy: chleb, masło, ser",
    "Do zrobienia: obiad, umyć podłogi",
    "weekend: kino, spacer z psem"
)

override fun onCreate(savedInstanceState: Bundle?) {

W funkcji onCreate() załadujemy początkowe dane do listy itemów treści. Dane do listy wprowadza się przy pomocy tak zwanego adaptera. Tworząc adapter podajemy kontekst aktywności, szablon widoku itemu (skorzystamy z wbudowanego do zasobów androida) oraz tablicę z treścią itemów.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //lista z widku układu
    var lista = findViewById<ListView>(R.id.ListView1)
    //utwórz lokalnego adaptera listy na podstawie układu simple_list_item_1
    var adapterListy=ArrayAdapter<String>(this,
		android.R.layout.simple_list_item_1,
		itemyTresci)
    lista.setAdapter(adapterListy)
}

Skompiluj aplikacje i sprawdź jej wygląd na emulatorze urządzenia mobilnego. Prawidłowo działająca aplikacja prezentuje się jak poniżej.

Dodajemy obsługę wprowadzania kolejnych treści

Kolejne treści kolekcji itemów odczytywane są z pola edycyjnego kontrolki EditText po kliknięciu kontrolki Button. Odświeżanie zawartości widocznej listy wykonuje metoda podpiętego adaptera listy. Nazwa metody to notifiDataChanged.

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    //lista z widku układu
    var lista = findViewById<ListView>(R.id.ListView1)
    //utwórz lokalnego adaptera listy na podstawie układu simple_list_item_1
    var adapterListy=ArrayAdapter<String>(this,
		android.R.layout.simple_list_item_1,
		itemyTresci)
    lista.setAdapter(adapterListy)
    //obsługa klikania w klawisz DODAJ
    val btDodaj=findViewById<Button>(R.id.button1)
    btDodaj.setOnClickListener {
        val txt=findViewById<EditText>(R.id.editText1)
        //dodaj nowa treśc do listy itemów treści
        itemyTresci.add(txt.text.toString())
        //uaktualnij zawartośc listy adaptera
        //jest to równoznaczne z uaktualnieniem widoku listy
        adapterListy.notifyDataSetChanged()
    }
}

Wynik działania klawisza DODAJ

Pełny kod rozwiązania

Zawartość pliku MainActivity.kt

import android.os.Bundle
import android.widget.ArrayAdapter
import android.widget.Button
import android.widget.EditText
import android.widget.ListView
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    var itemyTresci= arrayListOf<String>(
        "Zakupy: chleb, masło, ser",
        "Do zrobienia: obiad, umyć podłogi",
        "weekend: kino, spacer z psem"
    )

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //lista z widku układu
        var lista = findViewById<ListView>(R.id.ListView1)
        //utwórz lokalnego adaptera listy na podstawie układu simple_list_item_1
        var adapterListy=ArrayAdapter<String>(this,
			android.R.layout.simple_list_item_1,
			itemyTresci)
        lista.setAdapter(adapterListy)
        //obsługa klikania w klawisz DODAJ
        val btDodaj=findViewById<Button>(R.id.button1)
        btDodaj.setOnClickListener {
            val txt=findViewById<EditText>(R.id.editText1)
            //dodaj nowa treśc do listy itemów treści
            itemyTresci.add(txt.text.toString())
            //uaktualnij zawartośc listy adaptera
            //jest to równoznaczne z uaktualnieniem widoku listy
            adapterListy.notifyDataSetChanged()
        }
    }
}

Zawartość pliku activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    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:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginBottom="8dp"
        android:orientation="vertical"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="1.0"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="1.0">

        <LinearLayout
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal">

            <EditText
                android:id="@+id/editText1"
                android:layout_width="300dp"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:text="Nowy element"
                android:textSize="24sp" />

            <Button
                android:id="@+id/button1"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_weight="1"
                android:backgroundTint="#DC143C"
                android:text="DODAJ" />
        </LinearLayout>

        <ListView
            android:id="@+id/ListView1"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:drawSelectorOnTop="false"
            android:divider="#DC143C"
            android:dividerHeight="4px"/>
    </LinearLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

Kod rozwiązania

pobierz