Das schwebende Fenster ist eine der nützlichsten und benutzerfreundlichsten Funktionen auf mobilen Geräten. Es ermöglicht dem Benutzer, auf bestimmte Anwendungen oder Funktionen zuzugreifen, ohne seine aktuelle Arbeit zu unterbrechen. Häufig werden schwebende Fenster verwendet, um wichtige Informationen wie Notizen, Nachrichten oder die Verwaltung eines Mediaplayers anzuzeigen.
Wenn Sie eine Android–App entwickeln und Ihrem Projekt ein schwebendes Fenster hinzufügen möchten, machen Sie sich keine Sorgen - es ist nicht so schwierig, wie es scheinen mag. In diesem Artikel zeigen wir Ihnen, wie Sie ein schwebendes Fenster in wenigen einfachen Schritten erstellen.
Der erste Schritt besteht darin, eine Klasse für das schwebende Fenster zu erstellen. In dieser Klasse können Sie das Aussehen und Verhalten eines Fensters definieren und bei Bedarf zusätzliche Logik hinzufügen. Dann müssen Sie Code hinzufügen, um ein schwebendes Fenster auf dem Bildschirm anzuzeigen. Sie können dies mit verschiedenen Methoden wie WindowManager oder Overlay Packages tun.
Schritt 1: Erstellen eines neuen Projekts in Android Studio
Bevor Sie mit dem Erstellen eines unverankerten Fensters auf Android beginnen, müssen Sie ein neues Projekt in der Android Studio-Entwicklungsumgebung erstellen. Befolgen Sie diese einfachen Anweisungen, um ein neues Projekt zu erstellen:
| Schritt 1.1 | Öffnen Sie Android Studio und wählen Sie im Hauptmenü "Start a new Android Studio project". |
| Schritt 1.2 | Geben Sie im daraufhin angezeigten Fenster "Neues Projekt erstellen" einen Projektnamen ein, wählen Sie den Pfad zum Speichern des Projekts aus und wählen Sie den gewünschten Namen für das Anwendungspaket aus. |
| Schritt 1.3 | Wählen Sie die minimal unterstützte Version von Android aus, die Ihren Anforderungen entspricht. Klicken Sie auf "Next". |
| Schritt 1.4 | Wählen Sie eine Aktivitätsvorlage für Ihr Projekt aus. Die Vorlage legt fest, wie die Startaktivität Ihrer Anwendung aussehen wird. Sie können ein beliebiges Muster auswählen, das Ihren Bedürfnissen entspricht. Klicken Sie auf "Next". |
| Schritt 1.5 | Passen Sie die Aktivitätseinstellungen im nächsten Fenster an, indem Sie den Titel, das Layout und andere Optionen nach Belieben festlegen. Klicken Sie auf die Schaltfläche Fertig stellen, um ein neues Projekt zu erstellen. |
Nachdem Sie diesen Schritt abgeschlossen haben, können Sie in Ihrem neuen Projekt in Android Studio ein schwebendes Fenster auf Android erstellen.
Schritt 2: Hinzufügen der SYSTEM_ALERT_WINDOW-Berechtigung
Um ein schwebendes Fenster auf Android zu erstellen, müssen Sie Ihrem App-Manifest die Berechtigung SYSTEM_ALERT_WINDOW hinzufügen.
Diese Berechtigung ermöglicht es Ihrer Anwendung, Fenster über anderen Anwendungen anzuzeigen. Ohne diese Berechtigung wird Ihr schwebendes Fenster nicht angezeigt.
Um die Berechtigung SYSTEM_ALERT_WINDOW hinzuzufügen, öffnen Sie die AndroidManifest-Datei.xml im Stammordner Ihres Projekts und fügen Sie die folgende Codezeile in den Abschnitt ein :
Nachdem Sie diese Zeile hinzugefügt haben, wird die Berechtigung Ihrer App erfolgreich hinzugefügt. Ihre Anwendung verfügt jetzt über die erforderlichen Berechtigungen, um ein schwebendes Fenster zu erstellen.
Schritt 3: Erstellen einer Klasse für ein schwebendes Fenster
Um ein schwebendes Fenster auf Android zu erstellen, müssen Sie eine neue Klasse erstellen, die das Verhalten des Fensters steuert. In dieser Klasse werden wir alle notwendigen Methoden und Funktionen beschreiben, damit das Fenster funktioniert.
Beginnen wir damit, eine neue FloatingWindow-Klasse zu erstellen, die von der Service-Klasse erbt. Die Service-Klasse ermöglicht es uns, einen Hintergrunddienst zu erstellen, der im Hintergrund ausgeführt wird, ohne an eine bestimmte Aktivität gebunden zu sein.
In der FloatingWindow-Klasse beschreiben wir die onCreate() -Methode, die beim Erstellen des Dienstes aufgerufen wird und unser schwebendes Fenster initialisiert. Mit dieser Methode erstellen wir eine neue Instanz der WindowManager-Klasse, mit der wir die Anzeige von Fenstern auf dem Gerät steuern können.
Als nächstes beschreiben wir die Methoden onStartCommand() und onDestroy(), die aufgerufen werden, wenn der Dienst gestartet und beendet wird. In der onStartCommand() -Methode beschreiben wir die Logik für die Anzeige des schwebenden Fensters und dessen Verhalten, und in der onDestroy() -Methode geben wir alle Ressourcen frei und stoppen den Dienst.
Außerdem benötigen wir die createFloatingWindow() -Methode, um das Fenster selbst zu erstellen, und die setLayoutParams() -Methode, um Fensterparameter wie Breite, Höhe und Position festzulegen.
весь код класса Schwebendes Fenster будет выглядеть примерно так:
| öffentliche Klasse FloatingWindow erweitert den Dienst |
| privater Fenstermanager Fenstermanager; |
| private Ansicht Schwimmende Ansicht; |
| privater Fenstermanager.Layoutparameter Parameter; |
| @Überschreiben |
| öffentliche Leere onCreate() |
| Super.Erstellen(); |
| windowManager = (WindowManager) getSystemService(WINDOW_SERVICE); |
| Erstellen Sie Floatingwindow(); |
| > |
| @Überschreiben |
| public int onStartCommand(Intent intent, int flags, int startId) |
| // Hier können Sie die Logik der Anzeige des Fensters und seines Verhaltens vorschreiben |
| > |
| @Override |
| public void onDestroy() |
| // Freigeben von Ressourcen und Beenden des Dienstes |
| > |
| private void createFloatingWindow() |
| params = new WindowManager.LayoutParams( |
| WindowManager.LayoutParams.WRAP_CONTENT, |
| WindowManager.LayoutParams.WRAP_CONTENT, |
| WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY, |
| & |
Schritt 4: Erstellen eines Layouts für ein schwebendes Fenster
Wenn Sie ein schwebendes Fenster auf Android erstellen, ist es sehr wichtig, das Layout richtig zu gestalten. Das Layout bestimmt das Aussehen und die Position von Fensterelementen wie Text, Bildern und Schaltflächen. In diesem Schritt werden wir die grundlegenden Prinzipien zum Erstellen eines Layouts für ein schwebendes Fenster untersuchen.
Zuerst müssen Sie die Größe und Position des Fensters bestimmen. Es wird empfohlen, relative Einheiten wie dip oder sp zu verwenden, um sicherzustellen, dass das Fenster auf verschiedenen Geräten mit unterschiedlichen Bildschirmgrößen korrekt angezeigt wird.
Zweitens müssen Sie die Fensterelemente und ihre Position definieren. Es wird empfohlen, Container wie LinearLayout oder RelativeLayout zu verwenden, um Elemente zu gruppieren und die richtige Reihenfolge und den Einzug zwischen ihnen festzulegen. Sie können auch verschiedene Steuerelemente verwenden, z. B. TextView für Text, ImageView zum Anzeigen von Bildern und Button zum Erstellen von Schaltflächen.
Drittens ist es eine Überlegung wert, die Benutzeroberfläche und Benutzerfreundlichkeit zu berücksichtigen. Das schwebende Fenster sollte für den Benutzer einfach und intuitiv sein. Es wird empfohlen, klare und informative Elementnamen zu verwenden und bei Bedarf Hinweise oder detaillierte Informationen anzuzeigen.
Es muss daran erinnert werden, dass das Layout des schwebenden Fensters anpassungsfähig sein muss und auf allen Geräten gut aussehen sollte. Um dies zu erreichen, können Sie verschiedene Layouts für unterschiedliche Bildschirmgrößen verwenden oder verschiedene Stile für Elemente festlegen, um sie auf kleineren Bildschirmen kompakter zu machen.
Durch die richtige Erstellung eines Layouts für ein schwebendes Fenster können Sie eine schöne und funktionale Oberfläche erstellen, die benutzerfreundlich ist und sich gut mit Ihrer Anwendung verbindet.
Schritt 5: Initialisieren des Floating-Fensters in MainActivity
Nachdem Sie eine Klasse für ein schwebendes Fenster erstellt haben, müssen Sie sie jetzt in Ihrer Hauptaktivität (MainActivity) initialisieren.
Um zu beginnen, fügen Sie der onCreate-Methode Ihrer Aktivität den folgenden Code hinzu:
FloatingWindow floatingWindow = new FloatingWindow(this);floatingWindow.show();In der ersten Zeile erstellen wir ein neues Objekt der FloatingWindow-Klasse und übergeben den aktuellen Aktivitätskontext (this) an dieses Objekt.
In der zweiten Zeile rufen wir die show() -Methode auf, die ein schwebendes Fenster auf dem Bildschirm anzeigt.
Jetzt, wenn Sie die Anwendung starten, sollten Sie ein schwebendes Fenster sehen, das über Ihrer MainActivity-Aktivität schwebt.
Sie können dem schwebenden Fenster auch zusätzliche Funktionen und Einstellungen hinzufügen, z. B. Größe, Hintergrundfarbe, Text usw. festlegen. Sie können die Dokumentation der FloatingWindow-Klasse anzeigen, um mehr über die verfügbaren Methoden und Eigenschaften zu erfahren.
Im nächsten Schritt werden wir uns ansehen, wie Klickereignisse auf einem schwebenden Fenster behandelt werden.
Schritt 6: Ein schwebendes Fenster anzeigen
Um ein schwebendes Fenster anzuzeigen, müssen wir das Systemfenster WindowManager verwenden. Es ermöglicht uns, die gemeinsame Benutzeroberfläche zu verwalten und Fenster über anderen Anwendungen anzuzeigen.
Zuerst müssen wir einen Verweis auf den WindowManager mit getSystemService erhalten:
| WindowManager windowManager = (WindowManager) getSystemService(WINDOW_SERVICE); |
Dann erstellen wir ein WindowManager-Objekt.LayoutParams, das die Parameter unseres schwebenden Fensters beschreibt:
Hier geben wir die Breite und Höhe des Fensters an, den Typ des Fensters TYPE_APPLICATION_OVERLAY, mit dem das Fenster über anderen Anwendungen angezeigt werden kann, das Flag FLAG_NOT_FOCUSABLE, damit das Fenster nicht den Eingabefokus erhält, und das TRANSLUCENT-Pixelformat, damit das Fenster transparent ist.
Als nächstes können wir verschiedene Parameter für unsere LayoutParams festlegen. Sie können beispielsweise die Position eines Fensters angeben:
| layoutParams.x = 100; |
| layoutParams.y = 100; |
Jetzt haben wir alles, was wir brauchen, um unser Fenster anzuzeigen:
| windowManager.addView(view, layoutParams); |
Wobei view eine Instanz unserer benutzerdefinierten Ansicht ist, die wir zuvor erstellt haben.
Jetzt, da wir unser Fenster hinzugefügt haben, wird es über allen anderen Anwendungen angezeigt. Wir können es über den Bildschirm bewegen, seine Größe ändern und andere Aktionen mit dem schwebenden Fenster nach unseren Bedürfnissen ausführen.
Schritt 7: Konfigurieren des Floating-Fensterverhaltens
Nachdem Sie ein schwebendes Fenster auf Android erstellt haben, können Sie sein Verhalten mit einigen zusätzlichen Methoden und Eigenschaften anpassen.
1. setGravity() : Mit dieser Methode können Sie festlegen, welche Position das Fenster auf dem Bildschirm haben soll. Sie können eine der folgenden Optionen wählen: Gravity.START , Gravity.END , Gravity.TOP , Gravity.BOTTOM oder Gravity.CENTER .
2. SetX() und setY() : Mit diesen Methoden können Sie die X- und Y-Koordinaten eines schwebenden Fensters auf dem Bildschirm festlegen. Sie können sie verwenden, um das Fenster genau zu positionieren.
3. setWidth() und setHeight() : Mit diesen Methoden können Sie die Breite und Höhe des schwebenden Fensters festlegen. Sie können Werte in Pixeln oder als Prozentsatz der Bildschirmgröße angeben.
4. setFocusable() : Wenn Sie möchten, dass das schwebende Fenster fokussierbar ist und Benutzereingaben erhalten kann, können Sie diese Methode verwenden.
5. setOutsideTouchable() : Wenn Sie möchten, dass das Fenster geschlossen wird, wenn der Benutzer darüber hinaus klickt, können Sie diese Methode verwenden.
6. setAnimationStyle() : Mit dieser Methode können Sie eine Animation festlegen, die beim Öffnen oder Schließen des Fensters auf ein schwebendes Fenster angewendet wird.
7. update() : Wenn Sie Änderungen an den Einstellungen des schwebenden Fensters vorgenommen haben, müssen Sie diese Methode aufrufen, um das Fenster zu aktualisieren und die Änderungen anzuwenden.
Mit diesen Methoden können Sie das Verhalten Ihres schwebenden Fensters so anpassen, wie Sie es benötigen, und die Benutzerfreundlichkeit für die Benutzer sicherstellen.
Schritt 8: Hinzufügen von Funktionalität zum schwebenden Fenster
Nun, da wir bereits ein schwebendes Fenster auf Android haben, lassen Sie uns die Funktionalität hinzufügen. Wir können dies tun, indem wir unserem Code verschiedene Aktionen und Ereignishandler hinzufügen.
Zum Beispiel können wir eine Schaltfläche "Schließen" hinzufügen, damit der Benutzer das schwebende Fenster schließen kann. Dazu können wir das Button-Element aus dem Android SDK verwenden und es zu unserer Layout-Datei hinzufügen:
Dann können wir dieser Schaltfläche einen Ereignishandler zuweisen und Code hinzufügen, der das schwebende Fenster schließt, wenn Sie darauf klicken:
Button closeButton = (Button) floatingWindow.findViewById(R.id.closeButton);closeButton.setOnClickListener(new View.OnClickListener() >);Wenn Sie nun auf die Schaltfläche "Schließen" klicken, wird das schwebende Fenster geschlossen.
Sie können Ihrem schwebenden Fenster auch andere Funktionen hinzufügen, z. B. ein Textfeld zum Eingeben von Daten oder eine Schaltfläche zum Senden von Informationen hinzufügen. Dazu können Sie die entsprechenden Elemente aus dem Android SDK verwenden und Ereignishandler für diese Elemente hinzufügen.
Das Hinzufügen von Funktionalität zu Ihrem schwebenden Fenster auf Android ist daher ein sehr einfacher und intuitiver Prozess. Fügen Sie einfach die erforderlichen Elemente und Ereignishandler hinzu, und Ihr schwebendes Fenster ist bereit, mit der gewünschten Funktionalität zu arbeiten.
Schritt 9: Testen und Debuggen
Nachdem die Entwicklung eines Floating-Fensters auf Android abgeschlossen ist, ist es wichtig, seine Funktionalität zu testen und mögliche Fehler zu debuggen. Durch Tests wird sichergestellt, dass das Fenster ordnungsgemäß funktioniert und auf alle Benutzerinteraktionen reagiert.
Die folgenden Aspekte sollten während des Tests überprüft werden:
| 1. | Zeigt das Fenster auf verschiedenen Geräten und Bildschirmauflösungen korrekt an. Stellen Sie sicher, dass sich das Fenster an alle Bildschirmgrößen anpasst, ohne den Inhalt zu verzerren oder zu beschneiden. |
| 2. | Die Reaktion des Fensters auf verschiedene Benutzeraktionen, wie Tastenanschläge, Streichen und Texteingaben. Stellen Sie sicher, dass das Fenster alle diese Interaktionen korrekt verarbeitet und die erwartete Funktionalität bereitstellt. |
| 3. | Überprüfen Sie auf mögliche Fehler und Ausnahmen. Testen Sie jeden Aspekt der Funktion des Fensters sorgfältig und stellen Sie sicher, dass es keine unerwarteten Abstürze, Abstürze oder andere Probleme gibt. |
Während des Tests können Sie den Android-Emulator verwenden, um auf verschiedenen Betriebssystemversionen zu testen. Es wird auch empfohlen, das Fenster auf realen Geräten zu testen, um sicherzustellen, dass es in einer realen Umgebung funktioniert.
Wenn beim Testen Fehler oder Probleme auftreten, sollten Sie diese beheben und das Fenster erneut testen. Das Debuggen hilft Ihnen, mögliche Probleme im Code zu identifizieren und zu beheben und sicherzustellen, dass das Fenster stabil funktioniert.
Sobald das Fenster alle Tests und das Debugging erfolgreich abgeschlossen hat, ist es einsatzbereit. Jetzt können Sie das schwebende Fenster auf Ihrem Android-Gerät oder in Ihrer App erweitern und seine benutzerfreundliche und intuitive Benutzeroberfläche genießen.
