How to Make a Video Call App with ZEGOCLOUD

Möchten Sie Ihre eigene Videoanruf-App erstellen? Dank ZEGOCLOUD ist es einfacher, als Sie vielleicht denken. Diese Anleitung zeigt Ihnen Schritt für Schritt, wie Sie eine Videoanruf-App erstellen. ZEGOCLOUD bietet Tools, die den Prozess vereinfachen, selbst wenn Sie neu in der App-Entwicklung sind.

Sie erfahren, wie Sie Ihr Projekt einrichten, Videoanruffunktionen hinzufügen und dafür sorgen, dass Ihre App reibungslos läuft. Wir behandeln die Grundlagen, die Sie wissen müssen, von den ersten Schritten mit ZEGOCLOUD bis zum Testen Ihrer fertigen App. Am Ende verfügen Sie über eine funktionierende Videoanruf-App, die Sie selbst erstellt haben.

Ganz gleich, ob Sie Anfänger sind oder etwas Programmiererfahrung haben, dieser Leitfaden hilft Ihnen, schnell und einfach eine Videoanruf-App mit ZEGOCLOUD zu erstellen.

Wie lange dauert die Erstellung einer App?

Das Erstellen einer App nimmt Zeit in Anspruch und die genaue Dauer hängt von der Komplexität und den Funktionen der App ab. Die Entwicklung einfacher Apps mit Grundfunktionen kann etwa 2-3 Monate dauern. Diese Apps verfügen normalerweise über minimale Funktionen, wie zum Beispiel ein paar Bildschirme und Standardfunktionen.

Andererseits können komplexere Apps, die Funktionen wie Benutzerauthentifizierung, Datenbankintegration oder Echtzeitaktualisierungen umfassen, 4–6 Monate oder länger dauern. Diese Apps erfordern eine detailliertere Planung, Gestaltung und Tests, um sicherzustellen, dass alles reibungslos läuft.

Ein weiterer Faktor, der die Entwicklungszeit beeinflusst, ist die Größe des Teams, das an dem Projekt arbeitet. Ein größeres, erfahrenes Team kann die App schneller fertigstellen als eine kleinere Gruppe. Auch die Qualität der Kommunikation und des Projektmanagements spielt eine Rolle dabei, wie schnell die App fertiggestellt werden kann.

Es ist auch wichtig zu beachten, dass die App-Entwicklung nicht nach dem Start endet. Regelmäßige Updates und Wartung sind erforderlich, um Fehler zu beheben und den reibungslosen Betrieb der App sicherzustellen.

Insgesamt kann die Erstellung einer App je nach Umfang des Projekts zwischen einigen Monaten und über einem Jahr dauern. Eine gute Planung und ein klares Verständnis der Anforderungen der App können helfen, den Prozess zu beschleunigen.

iOS-App-Entwicklung vs. Android-App-Entwicklung: Was ist der Unterschied?

Beim Erstellen einer mobilen App können Sie zwischen iOS für Apple-Geräte oder Android für viele andere Telefone wählen. Beide sind beliebt, weisen jedoch einige wesentliche Unterschiede auf. Vergleichen wir sie:

Criteria	iOS App Development	Android App Development
Programming Language	Swift and Objective-C	Kotlin and Java
Development Environment	Xcode	Android Studio
Device Fragmentation	Less device variety, easier to test	Wide range of devices, harder to test
App Store Approval	Strict review process	Less strict, faster approval
Market Share	Popular in North America and Europe	Dominates in Asia, Africa, and more
Development Cost	Usually higher due to stricter guidelines	Can be lower, but depends on the complexity
Revenue Potential	Higher app revenue per user	Larger audience, but lower revenue per user

Hauptunterschiede:

• Programmiersprachen: iOS-Apps werden mit Swift oder Objective-C erstellt, während Android-Apps Kotlin oder Java verwenden. Swift ist neuer und einfacher zu erlernen, während Kotlin auf Android-Geräten vielseitiger ist.
• Gerätefragmentierung: iOS-Entwickler arbeiten mit weniger Gerätemodellen, was das Testen vereinfacht. Android-Entwickler müssen jedoch viele verschiedene Geräte und Bildschirmgrößen berücksichtigen.
• Umsatzpotenzial: iOS-Apps generieren häufig höhere Umsätze, insbesondere durch In-App-Käufe. Android-Apps erreichen ein größeres Publikum, verdienen aber möglicherweise weniger pro Nutzer.

Insgesamt bieten beide Plattformen einzigartige Vorteile, und die Wahl hängt von Ihrer Zielgruppe und Ihren Zielen ab.

So erstellen Sie eine Videoanruf-App für Android und iOS

Das Erstellen einer Videoanruf-App für Android und iOS mag schwierig erscheinen, aber mit den richtigen Tools ist es einfacher, als Sie denken. In diesem Abschnitt zeigen wir Ihnen, wie das mit dem ZEGOCLOUD Express SDK geht.

ZEGOCLOUD ist eine leistungsstarke Plattform, die es einfach macht, Ihren Apps Echtzeit-Video- und Audiofunktionen hinzuzufügen. Es kümmert sich um die komplizierten Teile, sodass Sie sich darauf konzentrieren können, Ihren Benutzern ein reibungsloses Erlebnis zu bieten. Mit ZEGOCLOUD ist die Erstellung einer Videoanruf-App für Android und iOS schnell und unkompliziert.

Voraussetzungen

Bevor wir beginnen, stellen wir sicher, dass Sie alles haben, was Sie brauchen:

• Melden Sie sich für ein ZEGOCLOUD-Entwicklerkonto an.
• Holen Sie sich Ihre AppID und AppSign vom ZEGOCLOUD-Admin-Dashboard.
• Sie müssen Android Studio 2020.3.1 oben installiert haben oder Xcode 13.0 für iOS-App.
• Verwenden Sie ein Gerät mit Android 4.4 oder iOS 9.0 oder höher, das Audio und Video unterstützt.
• Kenntnisse in der Entwicklung von Android- oder iOS-Apps.
• Stellen Sie sicher, dass Ihr Gerät mit dem Internet verbunden ist.

Android-Videoanruf-App

1. Hinzufügen der SDK-Abhängigkeiten

1.1 Gradle einrichten

Um das Zego SDK zu verwenden, müssen Sie das ZegoExpress SDK über Gradle zu Ihrem Android-Projekt hinzufügen. Befolgen Sie dazu die folgenden Schritte:

• Öffnen Sie für Android Studio Version 7.1.0 oder höher die Datei „settings.gradle“ Ihres Projekts. Fügen Sie den folgenden Code innerhalb des dependencyResolutionManagement-Blocks hinzu:

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        maven { url 'https://storage.zego.im/maven' }
        google()
        mavenCentral()
    }
}

• Öffnen Sie für ältere Versionen von Android Studio die Datei build.gradle im Stammverzeichnis Ihres Projekts. Fügen Sie den folgenden Code innerhalb des allprojects-Blocks hinzu:
  

  allprojects {
  repositories {
      maven { url 'https://storage.zego.im/maven' }
      google()
      mavenCentral()
  }
  }
  

1.2 Hinzufügen der SDK-Abhängigkeit

Öffnen Sie die Datei app/build.gradle. Fügen Sie die folgende Zeile innerhalb des Abhängigkeitsblocks hinzu (ersetzen Sie x.y.z durch die neueste SDK-Version):

dependencies {
    implementation 'im.zego:express-video:x.y.z'
}

Speichern Sie die Datei und synchronisieren Sie das Projekt. Dadurch wird das ZegoExpress SDK hinzugefügt und Videoanruffunktionen aktiviert.

2. Importieren des SDK

Sobald die Abhängigkeiten synchronisiert sind, importieren Sie das Zego SDK in Ihre Hauptaktivität, damit Sie mit der Implementierung von Videoanruffunktionen beginnen können.

Öffnen Sie Ihre MainActivity.java- oder MainActivity.kt-Datei. Fügen Sie die folgende Importanweisung hinzu:

import im.zego.zegoexpress.ZegoExpressEngine;

Mit diesem Import können Sie die Kernfunktionalität des Zego SDK nutzen.

3. Implementierung der Videoanruffunktion

3.1 App-Anmeldeinformationen definieren

Sie müssen Ihre AppID und AppSign definieren, die Sie von Ihrem ZEGOCLOUD-Dashboard erhalten haben.

Fügen Sie in Ihrer Hauptaktivitätsdatei die folgenden Variablen hinzu:

String appID = "<your app id>";  // Replace with your actual AppID
String appSign = "<your app sign>";  // Replace with your actual AppSign
</your></your>

3.2 Benutzer- und Rauminformationen definieren

Definieren Sie nun die Benutzer-ID, den Benutzernamen und die Raum-ID, um den Benutzer und den Videoanrufraum zu identifizieren. Definieren Sie die Variablen:

String userID = "<your userid>";   // Replace with your actual user ID
String userName = "<your username>"; // Replace with your actual user name
String roomID = "<your roomid>";   // Replace with your actual room ID
</your></your></your>

3.3 Initialisierung der Zego-Engine

Bevor Sie den Anruf starten, müssen Sie die Zego-Engine initialisieren. Diese Engine übernimmt alle Videoanrufvorgänge. Fügen Sie die folgende Methode hinzu, um die Engine zu initialisieren:

void createEngine() {
    ZegoEngineProfile profile = new ZegoEngineProfile();
    profile.appID = Long.parseLong(appID);
    profile.appSign = appSign;
    profile.application = getApplication();
    profile.scenario = ZegoScenario.DEFAULT; // Set the appropriate scenario
    ZegoExpressEngine.createEngine(profile, null);
}

Diese Methode initialisiert die ZegoExpressEngine mit der appID und appSign. Das Szenario ist auf STANDARD eingestellt, was für allgemeine Anwendungsfälle in Ordnung ist.

3.4 Einen Videoanruf starten und daran teilnehmen

Jetzt implementieren Sie Methoden zum Starten und Beitreten von Videoanrufen.

Videoanruf starten:

void startVideoCall() {
    ZegoExpressEngine.getEngine().startPublishingStream(roomID);
}

An einem Videoanruf teilnehmen:

void joinVideoCall() {
    ZegoExpressEngine.getEngine().startPlayingStream(roomID);
}

4. Geräteberechtigungen konfigurieren

Damit der Videoanruf auf Ihre Kamera und Ihr Mikrofon zugreifen kann, müssen Sie Berechtigungen in der Datei AndroidManifest.xml anfordern. Öffnen Sie die Datei AndroidManifest.xml und fügen Sie die folgenden Berechtigungen hinzu:

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

Für Android 6.0 und höher müssen Sie außerdem Laufzeitberechtigungen anfordern:

String[] permissions = {"android.permission.CAMERA", "android.permission.RECORD_AUDIO"};
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    requestPermissions(permissions, 101);
}

5. Ausführen und Testen Ihrer Android-App

Sobald Sie die Berechtigungen festgelegt haben, können Sie jetzt Ihre Android-App ausführen und testen:

• Build and run your app on a real Android device.
• Test the video call by starting the call on one device and joining the call on another using the same roomID.

iOS Video Call App

1. Adding the SDK Dependencies

1.1 Setting Up Swift Package Manager

For iOS, you will use Swift Package Manager to add the ZegoUIKitPrebuiltLiveStreaming SDK. Follow the steps below:

• Open Xcode, and go to File > Add Packages.
• In the search box, enter the following URL:

https://github.com/zegolibrary/express-video-ios

Select the latest version and add the package to your project.

2. Importing the SDK

Once the SDK is installed, you need to import it into your ViewController.swift file. In your ViewController.swift file, add the following import statements:

import ZegoUIKit
import ZegoUIKitPrebuiltLiveStreaming

These import statements give you access to the Zego video call SDK.

3. Implementing Video Call Functionality

3.1 Define App Credentials

You need your AppID and AppSign to authenticate your app with ZEGOCLOUD. Add the following credentials at the top of your ViewController.swift file:

let appID: UInt32 = <your appid>  // Replace with your actual AppID
let appSign: String = "<your appsign>"  // Replace with your actual AppSign
</your></your>

3.2 Define User and Room Information

Now, define the userID, userName, and roomID variables for identifying users and the room. Add these variables:

var userID: String = "<your userid>"   // Replace with actual user ID
var userName: String = "<your username>" // Replace with actual user name
var roomID: String = "<your roomid>"   // Replace with actual room ID
</your></your></your>

3.3 Initializing the Zego Engine

Like Android, you must initialize the Zego engine on iOS to handle video call functionality. Add the function below:

func createEngine() {
    let profile = ZegoEngineProfile()
    profile.appID = appID
    profile.appSign = appSign
    ZegoExpressEngine.createEngine(with: profile, eventHandler: self)
}

This function initializes the Zego engine with your credentials.

3.4 Starting and Joining a Video Call

To start a video call as a host:

func startVideoCall() {
    ZegoExpressEngine.shared().startPublishingStream(roomID)
}

To join an existing video call:

func joinVideoCall() {
    ZegoExpressEngine.shared().startPlayingStream(roomID)
}

4. Configuring Device Permissions

In iOS, you need to request camera and microphone permissions in the Info.plist file. Open the Info.plist file and add the following keys:

<key>NSCameraUsageDescription</key>
<string>We need access to your camera for video calls.</string>
<key>NSMicrophoneUsageDescription</key>
<string>We need access to your microphone for video calls.</string>

These entries will display permission prompts when the user first opens the app.

5. Running and Testing Your Video Call App

Once your permissions are set, you can now test your app:

• Open the .xcworkspace file in Xcode, select your target device, and run the app.
• Start a video call on one device, then join it from another device using the same room ID to test the feature.

These are just the basics. To add more features to your video call app, explore ZEGOCLOUD’s Express Video SDK documentation. You can also get started with our sample source code!

Conclusion

Building a video call app with ZEGOCLOUD is a straightforward process, whether you're developing for Android or iOS. By following this guide, you can set up your project, integrate essential video calling features, and test the app on real devices. ZEGOCLOUD’s powerful SDK simplifies the implementation, allowing you to focus on user experience rather than complex backend processes.

Start building your custom video call app today and create seamless communication experiences for your users.

The above is the detailed content of How to Make a Video Call App with ZEGOCLOUD. For more information, please follow other related articles on the PHP Chinese website!