Beim Aufruf vom DatePickerDialog erscheint immer eine Tastatur

Hallo zusammen

Ich habe in meinem Projekt eine EditText welches ein Datum enthält. Wenn ich das Feld anklicke soll ein Dialog zur Auswahl eines Datums erscheinen. In anderen Projekten habe ich es ebenfalls so gemacht und dort funktioniert es.

In meinem Projekt erscheint beim ersten Klick nur die Tastatur. Beim zweiten mal anklicken erscheint der Dialog aber im Hintergrund wird die Tastatur geöffnet. Wenn ich nun den Dialog mit OK abschliesse bleibt die Tastatur stehen.

Hier der Klick Methode

txt_datum.setOnClickListener(new EditText.OnClickListener() {
        @Override
        public void onClick(View v) {
            int n_jahr, n_monat , n_tag;
            n_jahr = kalender.get(Calendar.YEAR);
            n_monat = kalender.get(Calendar.MONTH);
            n_tag = kalender.get(Calendar.DAY_OF_MONTH);
            v.setFocusable(false);

            datumdialog = new DatePickerDialog(Main.this, listener, n_jahr, n_monat, n_tag);
            datumdialog.show();
        }
    });

und der listener

 private DatePickerDialog.OnDateSetListener listener = new DatePickerDialog.OnDateSetListener() {
    @Override
    public void onDateSet(DatePicker view, int year, int month, int dayOfMonth) {
        //gewähltes Datum setzen
        SimpleDateFormat sdf = new SimpleDateFormat(DD_MM_YYYY);
        kalender.set(year, month, dayOfMonth);
        datum = kalender.getTime();
        str_datum = sdf.format(datum);
        txt_datum.setText(str_datum);
        rechne();
    }
};

Kann mir jemand sagen was hier falsch läuft.
Zum Schluss noch die ganze Klasse

package ch.robbisoft.sun_app;

import android.app.Activity;
import android.app.DatePickerDialog;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.net.Uri;
import android.os.Build;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.design.widget.TabLayout;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.KeyEvent;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.WindowManager;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import static android.Manifest.permission.*;
import static java.lang.Math.floor;

public class Main extends AppCompatActivity
implements Frag_Sonne.OnFragmentInteractionListener,
Frag_Astro.OnFragmentInteractionListener,
Frag_Mond.OnFragmentInteractionListener,
AdapterView.OnItemSelectedListener {

public static final String APP = "SONNE";
public static final String FORMAT_DOUBLE = "%2.6f";
public static final String FORMAT_FLOAT = "%2.2f";
public static final String DD_MM_YYYY = "dd.MM.yyyy";
String[] rechte = new String[]{
        ACCESS_NETWORK_STATE,
        ACCESS_COARSE_LOCATION,
        ACCESS_FINE_LOCATION,
        WRITE_EXTERNAL_STORAGE,
        READ_EXTERNAL_STORAGE
};
String[] ZONE = { "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0",
"-1", "-2", "-3", "-4", "-5", "-6", "-7", "-8", "-9", "-10", "-11"};
private Spinner spi_zone;

private Context ctx;
private String str_text;
public static final int MULTIPLE_PERMISSIONS = 99;
private EditText txt_lang;
private EditText txt_breit;
private EditText txt_hoch;
private EditText txt_datum;
private Button btn_rechne;
private Animation anim_click;
private TabLayout tabulator;
private Fragment fragment = null;
private Date datum;
private Calendar kalender;
private DatePickerDialog datumdialog;

// private DatePickerDialog.OnDateSetListener listener;
private LocationManager posmanager;
private LocationListener horcher;

private Double b_breite = (double) 0;
private Double b_laenge = (double) 0;
private String str_datum = "";

//Variablen für Optionen
private int n_anzeige = 0;
private boolean b_findpos = true;
private boolean b_gps = false;
private int n_distanz = 1000;

public Integer getN_zone() {
    return n_zone;
}

public void setN_zone(Integer n_zone) {
    this.n_zone = n_zone;
}

private Integer n_zone;

public Double getB_breite() {
    return b_breite;
}

public void setB_breite(Double b_breite) {
    this.b_breite = b_breite;
}

public Double getB_laenge() {
    return b_laenge;
}

public void setB_laenge(Double b_laenge) {
    this.b_laenge = b_laenge;
}

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    ctx = getApplicationContext();
    //Verhindert dass eine Tastatur angezeigt wird
    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);

    txt_lang = findViewById(R.id.edt_lang);
    txt_breit = findViewById(R.id.edt_breit);
    txt_hoch = findViewById(R.id.edt_hoch);
    txt_datum = findViewById(R.id.edt_datum);
    spi_zone = (Spinner) findViewById(R.id.spi_zone);
    btn_rechne = (Button) findViewById(R.id.btn_rechne);
    anim_click = AnimationUtils.loadAnimation(getApplicationContext(), R.anim.button_click);

    //Spinner aufbauen
    spi_zone.setOnItemSelectedListener(this);
    ArrayAdapter aa = new ArrayAdapter(this,android.R.layout.simple_spinner_item, ZONE);
    aa.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
    spi_zone.setAdapter(aa);

    //Tabulatoren aufbauen
    tabulator = (TabLayout) findViewById(R.id.tab_anzeige);
    TabLayout.Tab tab_sonne = tabulator.newTab();
    tab_sonne.setText(getResources().getString(R.string.lbl_sonne));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        tab_sonne.setIcon(getDrawable(R.drawable.sun16x16));
    }
    TabLayout.Tab tab_astro = tabulator.newTab();
    tab_astro.setText(getResources().getString(R.string.lbl_astro));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        tab_astro.setIcon(getDrawable(R.drawable.astro16x16));
    }
    TabLayout.Tab tab_mond = tabulator.newTab();
    tab_mond.setText(getResources().getString(R.string.lbl_mond));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        tab_mond.setIcon(getDrawable(R.drawable.mond16x16));
    }
    tabulator.addTab(tab_sonne, true);
    tabulator.addTab(tab_astro);
    tabulator.addTab(tab_mond);
    //Den richtigen Tab öffnen
    tabulator.addOnTabSelectedListener((new TabLayout.BaseOnTabSelectedListener() {
        @Override
        public void onTabSelected(TabLayout.Tab tab) {
            //Selektieren der richtigen Seite
            switch (tab.getPosition()){
                case 0 :    fragment = new Frag_Sonne();
                    break;
                case 1 :    fragment = new Frag_Astro();
                    break;
                case 2 :    fragment = new Frag_Mond();
                    break;
            }
            //Parameter übergeben
            String str_breit, str_lang;
            str_breit = Double.toString(getB_breite());
            str_lang = Double.toString(getB_laenge());
            Bundle daten = new Bundle();
            daten.putString("BREITE", str_breit);
            daten.putString("LÄNGE", str_lang);
            daten.putString("DATUM", str_datum);
            daten.putString("ZONE", Integer.toString(getN_zone()));
            fragment.setArguments(daten);

            FragmentManager fm = getSupportFragmentManager();
            FragmentTransaction ft = fm.beginTransaction();
            ft.replace(R.id.simpleFrameLayout, fragment);
            ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
            ft.commit();
        }

        @Override
        public void onTabUnselected(TabLayout.Tab tab) {

        }

        @Override
        public void onTabReselected(TabLayout.Tab tab) {

        }
    }));
    //erste seite anzeigen
    fragment = new Frag_Sonne();
    FragmentManager fm = getSupportFragmentManager();
    FragmentTransaction ft = fm.beginTransaction();
    ft.replace(R.id.simpleFrameLayout, fragment);
    ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_OPEN);
    ft.commit();
    //Aktuelles Datum anzeigen
    SimpleDateFormat sdf = new SimpleDateFormat(DD_MM_YYYY);
    kalender = Calendar.getInstance();
    datum = kalender.getTime();
    str_datum = sdf.format(datum);
    txt_datum.setText(str_datum);
    txt_datum.setOnClickListener(new EditText.OnClickListener() {
        @Override
        public void onClick(View v) {
            int n_jahr, n_monat , n_tag;
            n_jahr = kalender.get(Calendar.YEAR);
            n_monat = kalender.get(Calendar.MONTH);
            n_tag = kalender.get(Calendar.DAY_OF_MONTH);
            v.setFocusable(false);

            datumdialog = new DatePickerDialog(Main.this, listener, n_jahr, n_monat, n_tag);
            datumdialog.show();
        }
    });

    btn_rechne.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            v.startAnimation(anim_click);
            rechne();
        }
    });

    //prüft ob OS Version > 6 ist, denn vorher kann nicht die Rechte geprüft werden
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        //prüfen ob Rechte vorhanden sind um auf die GPS Daten zu zugreifen
        if (pruefrechte()) {
            str_text = getResources().getString(R.string.lbl_start_neu);
            Toast.makeText(ctx, str_text, Toast.LENGTH_SHORT).show();
            initial();

        } else {
        }
    }else{
        str_text = getResources().getString(R.string.lbl_start_alt);
        Toast.makeText(ctx, str_text, Toast.LENGTH_SHORT).show();
        initial();
    }
    //Eingabe der länge und Breite von Hand
    txt_breit.setOnEditorActionListener(new EditText.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            String str_text;
            str_text = txt_breit.getText().toString();
            //Prüfen ob es wirklich nur eine Zahl ist
            int n_pos = str_text.indexOf("°");
            if( n_pos < 0 ){
                setB_breite(Double.parseDouble(str_text));
            }else {
                Toast.makeText(ctx, getResources().getString(R.string.txt_keineZahl), Toast.LENGTH_LONG).show();
            }
            //Tastatur schliessen
            KeyBoard.toggle(Main.this);
            zeig_pos();
            return true;
        }
    });
    txt_breit.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if( hasFocus ) {
                txt_breit.setText(getB_breite().toString());
            }
        }
    });
    txt_breit.setOnClickListener(new EditText.OnClickListener() {
        @Override
        public void onClick(View v) {
            String str_inhalt = txt_breit.getText().toString();
            int n_pos = str_inhalt.indexOf("°");
            if( n_pos > 0 ) {
                txt_breit.setText(getB_breite().toString());
            }
        }
    });
    txt_lang.setOnEditorActionListener(new EditText.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            String str_text;
            str_text = txt_lang.getText().toString();
            int n_pos = str_text.indexOf("°");
            if( n_pos < 0) {
                setB_laenge(Double.parseDouble(str_text));
            }else{
                Toast.makeText(ctx, getResources().getString(R.string.txt_keineZahl), Toast.LENGTH_LONG).show();
            }
            setN_zone(Astronomy.zeitzone(b_laenge));
            spi_zone.setSelection(getpos_zone(n_zone));
            //Tastatur schliessen
            KeyBoard.toggle(Main.this);
            zeig_pos();
            return true;
        }
    });
    txt_lang.setOnFocusChangeListener(new EditText.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if( hasFocus ) {
                txt_lang.setText(getB_laenge().toString());
            }
        }
    });
    txt_lang.setOnClickListener(new EditText.OnClickListener() {
        @Override
        public void onClick(View v) {
            String str_inhalt = txt_lang.getText().toString();
            int n_pos = str_inhalt.indexOf("°");
            if( n_pos > 0 ){
                txt_lang.setText(getB_laenge().toString());
            }
        }
    });
    //Fokus auf Button setzen
    btn_rechne.requestFocus(1);
    //Aktuelle Position setzen
    spi_zone.setSelection(getpos_zone(n_zone));
}

/**********************************************************************************************
* Ermittelt die Posiotn
*
* @author robbisoft @since 2. Juni 2019
* @param
* @return
**********************************************************************************************/
private void position(){
    posmanager = (LocationManager) getSystemService(LOCATION_SERVICE);
    horcher = new LocationListener() {
        @Override
        public void onLocationChanged(Location location) {
            Double lang = location.getLongitude();
            Double breit = location.getLatitude();
            Double hoch = (double) 0;
            if( location.hasAltitude() )
                hoch = location.getAltitude() - location.getAccuracy();

            setB_breite( breit );
            setB_laenge( lang );
            zeig_pos();
            txt_hoch.setText(hoch.toString());
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {

        }

        @Override
        public void onProviderEnabled(String provider) {

        }

        @Override
        public void onProviderDisabled(String provider) {

        }
    };
    //Position wird gesucht
    if( b_gps ) { //genau
        posmanager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, n_distanz, (LocationListener) horcher);
    }else { //ungenau
        posmanager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, n_distanz, (LocationListener) horcher);
    }
}

/**********************************************************************************************
* Ermittelt die Position, berechnet die Daten und stellt die ergebnisse dar
*
* @author robbisoft @since 2. Juni 2019
* @param
* @return
**********************************************************************************************/
private void initial(){
    //Gespeicherte Position lesen damit sofort was angezeigt wird
    lese_daten();
    Double b_breit = getB_breite();
    Double b_lang = getB_laenge();
    zeig_pos();
    setN_zone(Astronomy.zeitzone(b_lang));
    //Position ermitteln nur wenn gewünscht Optionen
    if( b_findpos ) {
        position();
    }
    //Parameter übergeben
    String str_breit, str_lang;
    str_breit = Double.toString(b_breit);
    str_lang = Double.toString(b_lang);
    Bundle daten = new Bundle();
    daten.putString("BREITE", str_breit);
    daten.putString("LÄNGE", str_lang);
    daten.putString("DATUM", str_datum);
    daten.putString("ZONE", Integer.toString(n_zone));
    fragment.setArguments(daten);
}

/**********************************************************************************************
* Prüft die Rechte der App
*
* @author robbisoft @since 7. Juni 2019
* @param
* @return
**********************************************************************************************/
private boolean pruefrechte(){
    int result;
    List listPermissionsNeeded = new ArrayList<>();
    for (String p:rechte)
    {
        result = ContextCompat.checkSelfPermission(this,p);
        if (result != PackageManager.PERMISSION_GRANTED)
        {
            listPermissionsNeeded.add(p);
        }
    }
    if (!listPermissionsNeeded.isEmpty())
    {
        ActivityCompat.requestPermissions(this, (String[]) listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]),MULTIPLE_PERMISSIONS );
        // keine permissions gesetzt
        return false;
    }
    // alle permissions gesetzt
    return true;
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode)
    {
        case MULTIPLE_PERMISSIONS:
        {
            if (grantResults.length > 0)
            {
                String permissionsDenied = getResources().getString(R.string.lbl_permission);
                for (String per : permissions)
                {
                    if(grantResults[0] == PackageManager.PERMISSION_DENIED)
                    {
                        permissionsDenied += "\n" + per;
                        Toast.makeText(ctx, permissionsDenied, Toast.LENGTH_LONG).show();
                    }
                }
                // Nach dem ersten Male
            }
            return;
        }
    }
}

@Override
public void onFragmentInteraction(Uri uri) {

}

@Override
public void onFragSelectet(int position) {
    Frag_Sonne frag_sonne = (Frag_Sonne)
            getSupportFragmentManager().findFragmentById(R.id.txt_dam_begin_wert);
    if(frag_sonne != null){

// frag_sonne.update_sonne( position );
}else{

    }
}

@Override
public void onPointerCaptureChanged(boolean hasCapture) {

}

@Override
protected void onDestroy() {
    super.onDestroy();

    double breit, lang;
    breit = getB_breite();
    lang = getB_laenge();
    schreibe_daten(breit, lang);
}

/**********************************************************************************************
* Liest die Daten aus dem Speicher
*
* @author robbisoft @since 8. Juni 2019
* @param
* @return
**********************************************************************************************/
private void lese_daten(){
    float breit, lang;
    SharedPreferences pref = getSharedPreferences(APP, 0);
    breit = pref.getFloat("BREIT", 0);
    setB_breite((double) breit);
    lang = pref.getFloat("LANG", 0);
    setB_laenge((double) lang);
    n_anzeige = pref.getInt("ANZEIGE", 0);
    b_findpos = pref.getBoolean("FINDPOS", true);
    b_gps = pref.getBoolean("GPS", false);
    n_distanz = pref.getInt("DISTANZ", 1000);
}

/**********************************************************************************************
* Schreibt die Daten in den Speicher
*
* @author robbisoft @since 28. August 2019
* @param 'Länge und Breite der aktuellen Position
* @return
**********************************************************************************************/
private void schreibe_daten(double breit, double lang){
    SharedPreferences pref = getSharedPreferences(APP, 0);
    SharedPreferences.Editor edit = pref.edit();
    edit.putFloat("BREIT", (float) breit);
    edit.putFloat("LANG", (float) lang);
    edit.putInt("ANZEIGE", n_anzeige);
    edit.putBoolean("FINDPOS", b_findpos);
    edit.putBoolean("GPS", b_gps);
    edit.putInt("DISTANZ", n_distanz);
    edit.commit();
}

/**********************************************************************************************
* Übergiebt die Parameter für die Fragmente
*
* @author robbisoft  @since 18. Juli 2019
* @param 'Breitengrad der Position
* @param 'Längengrad der Position
* @param 'Datum zum Berechnen
* @return
* @exception
* @throws
**********************************************************************************************/
private void rechne(){
    //Parameter übergeben
    String str_breit, str_lang;
    str_breit = Double.toString(getB_breite());
    str_lang = Double.toString(getB_laenge());
    Bundle daten = new Bundle();
    daten.putString("BREITE", str_breit);
    daten.putString("LÄNGE", str_lang);
    daten.putString("DATUM", str_datum);
    daten.putString("ZONE", Integer.toString(getN_zone()));
    fragment.setArguments(daten);
    if(fragment instanceof Frag_Sonne){
        ((Frag_Sonne) fragment).update_sonne(b_breite, b_laenge, datum, n_zone);
    }
    if(fragment instanceof Frag_Astro){
        ((Frag_Astro) fragment).update_astro(b_breite, b_laenge, datum, n_zone);
    }
    if(fragment instanceof Frag_Mond){
        ((Frag_Mond) fragment).update_mond(b_breite, b_laenge, datum, n_zone);
    }
}

@Override
public void onAttachFragment(Fragment fragment) {
    super.onAttachFragment(fragment);
    if (fragment instanceof Frag_Sonne) {
        Frag_Sonne frag = (Frag_Sonne) fragment;
        frag.setOnFragmentInteractionListener(this);
    }

}

@Override
protected void onStart() {
    super.onStart();
}

@Override
protected void onResume() {
    super.onResume();
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu_main, menu);
    return super.onCreateOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();
    switch (id){
        case R.id.mnu_optionen : {
            Intent AufRuf = new Intent(ctx, Optionen.class);

// startActivity(new Intent(ctx, Optionen.class));
AufRuf.putExtra("anzeige", n_anzeige);
AufRuf.putExtra("findpos", b_findpos);
AufRuf.putExtra("gps", b_gps);
AufRuf.putExtra("distanz", n_distanz);
startActivityForResult( AufRuf, 1 );
return true;
}
case R.id.mnu_savepos : {
Intent AufRuf = new Intent(ctx, SaveActivity.class);
AufRuf.putExtra("breit", b_breite);
AufRuf.putExtra("lang", b_laenge);
startActivity(AufRuf);
return true;
}
case R.id.mnu_loadpos : {
Intent AufRuf = new Intent(ctx, LoadActivity.class);
startActivityForResult(AufRuf, 2);
return true;
}
default : return super.onOptionsItemSelected(item);
}
}

@Override
public void onItemSelected(AdapterView<?> parent, View view, int n_position, long id) {
    int n_wer = parent.getId();
    switch ( n_wer){
        case R.id.spi_zone : {
            String item = parent.getItemAtPosition(n_position).toString();
            setN_zone(Integer.parseInt(item));
            rechne();
        }
    }
}

@Override
public void onNothingSelected(AdapterView<?> parent) {

}

/**********************************************************************************************
* Ermittelt die Position innerhalb des Arrays um den Spinner zu setzen
*
* @author robbisoft  @since 23. August 2019
* @param Aktuelle Zeitzone
* @return Position innerhalb vom Array
* @exception keine
* @throws keine
**********************************************************************************************/
private int getpos_zone( int n_aktuelle_zone ){
    int n_pos = 12;
    int n_pool = 0;
    String str_zone = null;

    for(int i=0; i < 13 ;i++){
        str_zone = ZONE[i].toString();
        n_pool = Integer.parseInt(str_zone);
        if(n_pool == n_aktuelle_zone){
            n_pos = i;
            return n_pos;
        }
    }

    return n_pos;
}

/**********************************************************************************************
* Berechnet die Position in Grad und Stunden und gibt alles als String zurück
*
* @author robbisoft  @since 27. August 2019
* @param Position in double
* @return Position in Grad und Stunden
* @exception
* @throws
**********************************************************************************************/
private String pos2hhmm ( double b_position) {
    String str_text = null;
    int stunde;
    double minute;

    if( b_position < 0) {
        stunde = (int) floor(b_position);
        b_position += (stunde * -1);
        minute = (double) (b_position * -60);
    }else{
        stunde = (int) floor(b_position);
        b_position -= stunde;
        minute = (double) b_position * 60;
    }
    str_text = Integer.toString(stunde);
    str_text += "°";
    str_text += String.format(FORMAT_FLOAT, minute);
    str_text += "'";

    return str_text;
}

/**********************************************************************************************
* Berechnet die Position in Grad Stunden und minuten um und gibt alles als String zurück
*
* @author robbisoft  @since 27. August 2019
* @param Position
* @return String in Grad Minuten und Sekunden
* @exception
* @throws
**********************************************************************************************/
private String pos2hhmmss ( double b_position ){
    String str_text = null;
    int stunde, minute;
    double sekunde;

    if( b_position < 0) {
        stunde = (int) floor(b_position);
        b_position += (stunde * -1);
        b_position *= -60;
        minute = (int) floor(b_position);
        b_position += (minute * -1);
        sekunde = (double) b_position * -60;
    }else{
        stunde = (int) floor(b_position);
        b_position -= stunde;
        b_position *= 60;
        minute = (int) floor(b_position);
        b_position -= minute;
        sekunde = (double) b_position * 60;
    }
    str_text = Integer.toString(stunde);
    str_text += "°";
    str_text += Integer.toString(minute);
    str_text += "'";
    str_text += String.format(FORMAT_FLOAT, sekunde);
    str_text += "''";

    return str_text;
}

/**********************************************************************************************
* Gibt die Position als String zurück
*
* @author robbisoft  @since 27. August 2019
* @param Position
* @return String in Grad
* @exception
* @throws
**********************************************************************************************/
private String pos2string ( double b_position ) {
    String str_text = null;

    str_text = String.format(FORMAT_DOUBLE, b_position);
    str_text += "°";

    return str_text;
}

/**********************************************************************************************
* Gibt die Position als String zurück je nach option
*
* @author robbisoft  @since 27. August 2019
* @param Position
* @param welcher String soll ausgegeben werden
* @return zusammengesetzter String
* @exception
* @throws
**********************************************************************************************/
private String pos2str ( double d_pos, int n_was ) {
    switch ( n_was ){
        case 0 : return pos2string(d_pos);
        case 1 : return pos2hhmm(d_pos);
        case 2 : return pos2hhmmss(d_pos);
        default: return pos2string(d_pos);
    }
}

/**********************************************************************************************
* Stellt die Position in den Feldern an
*
* @author robbisoft  @since 28. August 2019
* @param
* @return
* @exception
* @throws
**********************************************************************************************/
private void zeig_pos(){
    txt_lang.setText(pos2str(getB_laenge(), n_anzeige));
    txt_breit.setText(pos2str(getB_breite(), n_anzeige));
}

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    switch (requestCode){
        case 1 : {
            n_anzeige = data.getIntExtra("anzeige", 0);
            b_findpos = data.getBooleanExtra("findpos", true);
            b_gps = data.getBooleanExtra("gps", true);
            n_distanz = data.getIntExtra("distanz", 1000);
            zeig_pos();
            break;
        }
        case 2 : {
            Double ort_breit, ort_lang;
            try {
                ort_breit = data.getDoubleExtra("ort_breit", 0);
                ort_lang = data.getDoubleExtra("ort_lang", 0);
                setB_breite(ort_breit);
                setB_laenge(ort_lang);
                zeig_pos();
                rechne();
            }catch (Exception e){

            }
        }
    }
}

//Beim anklicken Datumsdialog anzeigen
private DatePickerDialog.OnDateSetListener listener = new DatePickerDialog.OnDateSetListener() {
    @Override
    public void onDateSet(DatePicker view, int year, int month, int dayOfMonth) {
        //gewähltes Datum setzen
        SimpleDateFormat sdf = new SimpleDateFormat(DD_MM_YYYY);
        kalender.set(year, month, dayOfMonth);
        datum = kalender.getTime();
        str_datum = sdf.format(datum);
        txt_datum.setText(str_datum);
        rechne();
    }
};

}

Gruss Renato

Ciao Jokel

Zum Schluss schtellst du eine gute Frage. Ich weiss es auch nicht. Mal schauen was geschieht wenn ich es ändere.

Gruss Renato