Hvordan ændrer man menuer og menuitems under runtime i Android?

I Android udvikling er det et velkendt princip, at det er bedst at skabe brugergrænseflader (UI) via XML snarere end Java-kode. Dog er der situationer, hvor det er nødvendigt at håndtere UI-elementer direkte i koden. Et klassisk eksempel på dette opstår, når man ønsker at ændre synligheden eller aktivere/deaktivere bestemte menuindgange baseret på eksterne betingelser eller brugerinteraktion. Dette kan være tilfældet, hvis du kun ønsker at vise en menuindgang for upload, hvis brugeren er logget ind.

I denne guide vil vi udforske, hvordan man dynamisk kan oprette og ændre en menu i Android ved hjælp af kode under runtime.

For at komme i gang, åbner vi res/strings.xml-filen og tilføjer de nødvendige strenge for vores menupunkter samt en knap til at skifte synligheden af menuen. Vi tilføjer følgende strenge i filen:

xml
Copy code
<string name="menu_download">Download</string>

<string name="menu_settings">Settings</string>

I activity_main.xml tilføjer vi en knap, som ved klik vil kalde en metode, der ændrer synligheden af menuen:

xml
Copy code
<Button
    android:id="@+id/toggle_button"
    android:text="Toggle Menu"
    android:onClick="toggleMenu" />

Derefter åbner vi ActivityMain.java og definerer nogle variable og metoder. Først tilføjer vi følgende tre linjer lige under klassens deklaration:

java
Copy code
private final int MENU_DOWNLOAD = 1;

private final int MENU_SETTINGS = 2;

private boolean showDownloadMenu = false;

Dernæst opretter vi en metode, der kaldes, når knappen trykkes:

java
Copy code
public void toggleMenu(View view) {
    showDownloadMenu = !showDownloadMenu;
}

Når aktiviteten først oprettes, kalder Android onCreateOptionsMenu() for at oprette menuen. Her er koden, der dynamisk bygger menuen:

java
Copy code
@Override

public boolean onCreateOptionsMenu(Menu menu) {
    menu.add(0, MENU_DOWNLOAD, 0, R.string.menu_download);
    menu.add(0, MENU_SETTINGS, 0, R.string.menu_settings);
    return true;
}

Det anbefales dog at bruge onPrepareOptionsMenu() i stedet for at opdatere eller ændre menuen i onCreateOptionsMenu(). På den måde sikrer vi, at menuen bliver opdateret korrekt under runtime. Her er koden til at ændre synligheden af downloadmenuen baseret på vores flag:

java
Copy code
@Override

public boolean onPrepareOptionsMenu(Menu menu) {
    MenuItem menuItem = menu.findItem(MENU_DOWNLOAD);
    menuItem.setVisible(showDownloadMenu);
    return true;
}

For at reagere på valgte menupunkter kan du oprette en onOptionsItemSelected() metode:

java
Copy code
@Override

public boolean onOptionsItemSelected(MenuItem item) {

    switch (item.getItemId()) {
        case MENU_DOWNLOAD:
            Toast.makeText(this, R.string.menu_download, Toast.LENGTH_LONG).show();
            break;
        case MENU_SETTINGS:
            Toast.makeText(this, R.string.menu_settings, Toast.LENGTH_LONG).show();
            break;
        default:
            return super.onContextItemSelected(item);
    }
    return true;
}

Nu kan du køre programmet på en enhed eller emulator for at se ændringerne i menuen.

Sådan fungerer det: Vi har overskrevet onCreateOptionsMenu(), som vi også gjorde i den tidligere opskrift om at oprette en optionsmenu. I stedet for at "inflate" en eksisterende menu-ressource, bruger vi Menu.add() metoden til at tilføje menuindgange dynamisk. For at kunne reagere på valgte menupunkter og ændre menuelementer senere, definerede vi vores egne menu-ID'er og brugte dem i add() metoden.

onOptionsItemSelected() kaldes for alle menupunkter, så vi kan bruge en switch-sætning til at håndtere hvert punkt baseret på de ID'er, vi definerede. Hvis vi håndterer menu-hændelsen, returnerer vi true; ellers videregiver vi hændelsen til superklassen. Ændringen af menuen sker i onPrepareOptionsMenu(). For at simulere en ekstern hændelse oprettede vi en knap til at ændre et boolesk flag. Synligheden af downloadmenuen bestemmes af dette flag. Her vil du implementere din egen logik baseret på dine egne kriterier.

En ekstra funktionalitet kan være at vise menuen i Action Bar. Dette kan gøres ved at tilføje følgende linje i onPrepareOptionsMenu() før returnering:

java
Copy code
menuItem.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);

java
Copy code
invalidateOptionsMenu();

Denne invalidateOptionsMenu() opfordrer Android til at opdatere menuen og kalde onPrepareOptionsMenu() igen, hvilket giver den ønskede opførsel.

Når vi arbejder med runtime ændringer af menuer, er det vigtigt at forstå, hvordan Android opfatter menuer og deres interaktion med brugergrænsefladen. At manipulere menuer i koden kræver præcis kontrol over hændelser og synlighed. Det betyder, at udvikleren skal være opmærksom på de betingelser, der påvirker, hvornår og hvordan en menuindgang vises eller ændres. Dette kan omfatte brugerens loginstatus, tilgængelighed af data, eller endda appens interne tilstand. At forstå og håndtere disse betingelser korrekt er en grundlæggende færdighed for at skabe dynamiske og brugervenlige Android-applikationer.

Hvordan fungerer kontekstuelle handlinger i Android?

For at implementere kontekstuelle handlinger i Android-applikationer, især når der arbejdes med ListViews, er det nødvendigt at forstå de centrale koncepter bag multi-valg tilstand og kontekstuelle menuer. Dette kapitel vil fokusere på, hvordan du kan tilføje en kontekstuel handlingsmenu (CAB) til din app ved at bruge MultiChoiceModeListener og hvordan du håndterer brugerens valg gennem forskellige menufunktioner.

Når du arbejder med en ListView og ønsker at tilføje kontekstuelle handlinger, skal du sikre dig, at ChoiceMode er sat til CHOICE_MODE_MULTIPLE_MODAL. Denne tilstand gør det muligt for brugeren at vælge flere elementer og anvende handlinger på flere valgte elementer samtidigt, hvilket er en vigtig funktion i mange applikationer. Den grundlæggende funktionalitet opnås ved at oprette et MultiChoiceModeListener, som håndterer interaktioner, når brugeren vælger et eller flere elementer.

Når du definerer MultiChoiceModeListener, opretter du først en kontekstuel menu ved at implementere onCreateActionMode. Denne metode inflater menuen, som derefter vises i appen. I praksis vil menuen blive vist, når brugeren interagerer med et element i ListView gennem et langt tryk eller en anden form for handling, som kan udløse den kontekstuelle tilstand. Det er dog også muligt at ændre standardadfærden, så konteksttilstanden udløses, når et element markeres som valgt, uden at brugeren behøver at udføre et langt tryk.

Et centralt element i dette design er at sikre, at brugerens interaktion med listen er intuitiv. Når et element er markeret, vil systemet aktivere den kontekstuelle handlingsmenu, og brugeren vil få mulighed for at vælge blandt de tilgængelige handlinger, såsom "Flyt" eller "Slet". Disse handlinger vil blive defineret i din menu-XML og håndteres gennem onActionItemClicked-metoden i din MultiChoiceModeListener.

Derudover er det vigtigt at bemærke, at du kan bruge en PopupMenu til at tilføje en enkel pop-up menu, som kan knyttes til en specifik visuel komponent som en knap. Denne form for menu bruges typisk, når du ønsker at give brugeren adgang til ekstra muligheder, uden at ændre på den primære brugerflade. Eksempler på brug af pop-up menuer kan være knapper som "Svar", "Svar alle" eller "Videresend" i en e-mail-applikation.

I forhold til kontekstuelle handlinger er det også vigtigt at forstå, hvordan din app's layout kan ændre sig, når en Action Bar er synlig. Hvis du har en Action Bar, vil den blive overlejret af den kontekstuelle handlingsmenu, hvilket kan ændre udseendet af din app. Hvis du ikke har en Action Bar som standard, vil layoutet blive opdateret for at inkludere den kontekstuelle handlingsmenu. Det er derfor en god idé at være opmærksom på dette, især hvis din app har en kompleks brugergrænseflade.

Når du designer brugeroplevelsen, bør du overveje, hvordan kontekstuelle handlinger og pop-up menuer kan bruges sammen for at forbedre brugervenligheden. Det er ikke kun vigtigt at tilbyde de rette funktioner, men også at gøre det nemt for brugeren at forstå, hvordan de kan interagere med appen. Dette betyder, at alle menuer skal være let tilgængelige og funktionelle, samtidig med at de ikke forstyrrer den overordnede brugeroplevelse.

Det er også væsentligt at forstå, at forskellige menu-typer bør anvendes afhængigt af den specifikke situation. En PopupMenu er for eksempel bedst egnet til handlinger, der er relateret til en enkelt visuel komponent, mens en kontekstuel handlingsmenu er bedst til at håndtere valg, der involverer flere elementer i en liste. Ved at vælge den rette menu- og handlingsmekanisme kan du sikre, at din app er både funktionel og nem at bruge.

Hvordan får man den sidste kendte position i Android?

I denne opskrift vil vi tage et kig på en grundlæggende funktionalitet, der ofte er nødvendig i mange applikationer: hvordan man får den sidste kendte position. Dette er en enkel metode til at bruge API'er med minimal ressourceforbrug, hvilket betyder, at din app ikke vil være ansvarlig for at dræne batteriet. Samtidig fungerer dette som en god introduktion til opsætning af Google Location API'er.

Forberedelse
For at begynde, skal vi oprette et nyt projekt i Android Studio. Når du bliver bedt om at vælge en aktivitet, skal du vælge "Google Maps Activity" i stedet for den normale "Blank Activity". Dette giver os en grundlæggende opsætning til at bruge geolokalisering.

Når projektet er oprettet, skal du åbne Android Manifest og tilføje de nødvendige tilladelser for at få adgang til brugerens placering. Dernæst åbner du filen build.gradle (Module: app) og tilføjer følgende afhængighed under sektionen "dependencies":
compile 'com.google.android.gms:play-services:8.4.0'.

Opsætning af layout og kode
Nu skal vi opsætte brugergrænsefladen. Åbn activity_main.xml og erstat den eksisterende TextView med følgende XML-kode:

xml
Copy code
<TextView

    android:id="@+id/textView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Location info will appear here"
    android:layout_centerInParent="true"/>
<Button
    android:id="@+id/button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Get Last Location"
    android:layout_below="@id/textView"
    android:layout_centerHorizontal="true"/>

Dernæst skal vi definere globale variabler i MainActivity.java for at referere til GoogleApiClient, TextView og Button:

java
Copy code
GoogleApiClient mGoogleApiClient;
TextView mTextView;
Button mButton;

java
Copy code
GoogleApiClient.ConnectionCallbacks mConnectionCallbacks = new GoogleApiClient.ConnectionCallbacks() {
    @Override
    public void onConnected(Bundle bundle) {
        mButton.setEnabled(true);
    }
    @Override

    public void onConnectionSuspended(int i) {}

};

For at håndtere forbindelsesfejl, tilføjes en listener:

java
Copy code
GoogleApiClient.OnConnectionFailedListener mOnConnectionFailedListener = new GoogleApiClient.OnConnectionFailedListener() {
    @Override

    public void onConnectionFailed(ConnectionResult connectionResult) {

        Toast.makeText(MainActivity.this, connectionResult.toString(), Toast.LENGTH_LONG).show();
    }
};

I onCreate()-metoden tilføjer vi de nødvendige initialiseringer:

java
Copy code
mTextView = (TextView) findViewById(R.id.textView);
mButton = (Button) findViewById(R.id.button);
mButton.setEnabled(false);
setupGoogleApiClient();

Så opretter vi metoden setupGoogleApiClient() for at konfigurere GoogleApiClient:

java
Copy code
protected synchronized void setupGoogleApiClient() {

    mGoogleApiClient = new GoogleApiClient.Builder(this)
        .addConnectionCallbacks(mConnectionCallbacks)
        .addOnConnectionFailedListener(mOnConnectionFailedListener)
        .addApi(LocationServices.API)
        .build();
    mGoogleApiClient.connect();
}

Endelig implementerer vi knapfunktionaliteten, som henter den sidste kendte position, når brugeren trykker på knappen:

java
Copy code
public void getLocation(View view) {
    try {
        Location lastLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
        if (lastLocation != null) {
            mTextView.setText(
                DateFormat.getTimeInstance().format(lastLocation.getTime()) + "\n" +
                "Latitude=" + lastLocation.getLatitude() + "\n" + 
                "Longitude=" + lastLocation.getLongitude());
        } else {
            Toast.makeText(MainActivity.this, "null", Toast.LENGTH_LONG).show();
        }
    } catch (SecurityException e) {
        e.printStackTrace();
    }
}

Når du har skrevet denne kode, kan du køre applikationen på en fysisk enhed eller emulator. Når knappen trykkes, vises den sidste kendte position i tekstfeltet.

Hvordan det virker
For at kunne kalde metoden getLastLocation(), skal vi først opsætte GoogleApiClient. Dette gøres ved at bruge GoogleApiClient.Builder i metoden setupGoogleApiClient() og oprette forbindelsen. Når forbindelsen er oprettet, kaldes metoden onConnected() fra ConnectionCallbacks, og her aktiverer vi knappen. Knappen giver os mulighed for at kalde getLastLocation() manuelt, da systemet i baggrunden allerede opdaterer enhedens position.

Det er vigtigt at bemærke, at systemet selv opdaterer positionen, og der er ikke noget garanti for, at den sidste kendte position ændres ved hver opkald. Dette kan ses i tidsstemplet, som viser tidspunktet for den sidste position, ikke tidspunktet for knaptrykket.

Yderligere overvejelser
En vigtig detalje er den præcision, som vi får i den modtagne position. Ved at bruge tilladelsen ACCESS_COARSE_LOCATION får vi en grov position, men for højere præcision kan vi anmode om tilladelsen ACCESS_FINE_LOCATION.

Testning af positionen
Testning af position kan være udfordrende, især når du forsøger at simulere GPS-bevægelser. For at lette testningen tilbyder Android Studio mulighed for at simulere GPS-data på en emulator. Dette kan også gøres med fysiske enheder, men det kræver ekstra opsætning. For at simulere en position i Android Studio skal du gå til "Tools" -> "Android" -> "Android Device Monitor", vælge "Emulator Control"-fanen, og indtaste GPS-koordinater i sektionen "Location Controls".

Bemærk, at test af getLastLocation() muligvis ikke viser den simulerede GPS-position, da den bruger flere sensorer (ikke kun GPS) til at bestemme positionen. For at sikre, at mock-data fungerer korrekt, bør du overveje at implementere metoden til at anmode om positionopdateringer, som giver systemet mulighed for at vælge den mest passende sensor.

Hvordan opretter man alarmer og håndterer enhedens opstart i Android?

For at komme i gang med at oprette en alarm i Android, skal du først oprette et nyt projekt i Android Studio og navngive det "Alarms". Vælg standardmuligheden for "Phone & Tablet" og vælg "Empty Activity", når du bliver bedt om at vælge en aktivitetstype. En alarm i Android kræver en Pending Intent, som systemet sender, når alarmen bliver aktiveret. Derfor skal du opsætte en BroadcastReceiver, som kan modtage alarmens intention.

Åbn derefter AndroidManifest.xml og tilføj følgende tilladelser og indstillinger til dit manifest:

xml
Copy code
<receiver android:name=".AlarmBroadcastReceiver" android:enabled="true" android:exported="true" android:permission="android.permission.SET_ALARM">
    <intent-filter>

        <action android:name="com.packtpub.androidcookbook.alarms.ACTION_ALARM"/>

    </intent-filter>
</receiver>

Herefter åbnes filen activity_main.xml, hvor du erstatter eksisterende TextView med en simpel knap til at sætte alarmen:

xml
Copy code
<Button
    android:id="@+id/set_alarm_button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Set Alarm"
    android:onClick="setAlarm"/>

Opret en ny Java-klasse kaldet AlarmBroadcastReceiver, som vil håndtere alarmen, når den går af:

java
Copy code
public class AlarmBroadcastReceiver extends BroadcastReceiver {

    public static final String ACTION_ALARM = "com.packtpub.androidcookbook.alarms.ACTION_ALARM";
    @Override
    public void onReceive(Context context, Intent intent) {
        if (ACTION_ALARM.equals(intent.getAction())) {
            Toast.makeText(context, ACTION_ALARM, Toast.LENGTH_SHORT).show();
        }
    }
}

I ActivityMain.java kan du nu tilføje metoden for knapklik, som starter alarmen:

java
Copy code
public void setAlarm(View view) {

    Intent intentToFire = new Intent(getApplicationContext(), AlarmBroadcastReceiver.class);
    intentToFire.setAction(AlarmBroadcastReceiver.ACTION_ALARM);

    PendingIntent alarmIntent = PendingIntent.getBroadcast(getApplicationContext(), 0, intentToFire, 0);

    AlarmManager alarmManager = (AlarmManager) getApplicationContext().getSystemService(Context.ALARM_SERVICE);

    long thirtyMinutes = SystemClock.elapsedRealtime() + 30 * 60 * 1000;

    alarmManager.set(AlarmManager.ELAPSED_REALTIME, thirtyMinutes, alarmIntent);
}

Når du kører appen på en enhed eller emulator, vil alarmen blive udløst efter 30 minutter. Hvis du trykker på "Set Alarm" igen, før alarmen er udløst, vil den første alarm blive overskrevet af den nye, da de begge bruger den samme Pending Intent.

Hvis du ønsker at annullere alarmen, kan du bruge metoden cancel() med den samme Pending Intent, som blev brugt til at oprette alarmen:

java
Copy code
alarmManager.cancel(alarmIntent);

For at oprette en gentagen alarm kan du bruge setRepeating() metoden, som ligner set(), men her kan du angive et interval:

java
Copy code
alarmManager.setRepeating(AlarmManager.ELAPSED_REALTIME, thirtyMinutes, AlarmManager.INTERVAL_HALF_HOUR, alarmIntent);

Denne metode gør det muligt at vælge mellem forskellige foruddefinerede intervaller som f.eks. INTERVAL_DAY, INTERVAL_FIFTEEN_MINUTES eller INTERVAL_HOUR.

En anden vigtig funktion er at kunne håndtere enhedens opstart. Android sender flere intents under enhedens livscyklus, og én af de første intents er ACTION_BOOT_COMPLETED. Hvis din applikation skal vide, hvornår enheden genstarter, skal du kunne fange dette intent.

Først skal du tilføje den nødvendige tilladelse i AndroidManifest.xml:

xml
Copy code
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>

Derefter tilføjes en BroadcastReceiver, som lytter efter opstarten af enheden:

java
Copy code
public class BootBroadcastReceiver extends BroadcastReceiver {
    @Override

    public void onReceive(Context context, Intent intent) {

        if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
            Toast.makeText(context, "BOOT_COMPLETED", Toast.LENGTH_SHORT).show();
        }
    }
}

For at sikre, at din app modtager notifikationer om enhedens opstart, skal du registrere modtagelse af BOOT_COMPLETED i manifestet, og her vil din app kunne genoprette alarmerne, hvis det er nødvendigt.

Når enheden starter op, vil Android sende BOOT_COMPLETED-intentet. Hvis appen har tilladelse til at modtage dette intent, vil den udføre koden i BroadcastReceiver'en. Hvis du tidligere har oprettet alarmer, kan du genoprette dem i onReceive() metoden.

Det er vigtigt at bemærke, at du kan kombinere flere handlinger i samme BroadcastReceiver, så du ikke nødvendigvis behøver en separat modtager for hver type action. Her er et eksempel på, hvordan du kan håndtere flere handlinger:

java
Copy code
public void onReceive(Context context, Intent intent) {

    if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
        Toast.makeText(context, "BOOT_COMPLETED", Toast.LENGTH_SHORT).show();
    } else if (intent.getAction().equals("com.example.another_action")) {
        // Håndter en anden handling
    }
}

Ved at kombinere alarmhåndtering og opstartshåndtering kan din app automatisk reagere på systemændringer som enhedens opstart og genoprette eventuelle nødvendige alarmer. Dette kan være nyttigt i scenarier, hvor brugeren forventer, at appen fortsætter med at køre og genererer påmindelser selv efter en systemgenstart.