From 7b5e8e56c20c2ffaa8689daecce3f984e16587eb Mon Sep 17 00:00:00 2001
From: Littlegnal <8847263+littleGnAl@users.noreply.github.com>
Date: Tue, 26 Oct 2021 14:09:07 +0800
Subject: [PATCH] feat: [Android] Implement custom audio source example (#475)

---
 example/android/app/build.gradle              |   9 +
 .../android/app/src/main/AndroidManifest.xml  |   5 +
 .../agora_rtc_engine_example/MainActivity.kt  |  25 ++
 .../AudioRecordService.java                   | 195 +++++++++++++
 .../custom_audio_source/AudioStatus.java      |   7 +
 .../custom_audio_source/CustomAudioPlugin.kt  |  73 +++++
 .../CustomAudioSource.java                    | 156 +++++++++++
 example/ios/Runner/CustomAudioSource.h        |  24 ++
 example/ios/Runner/CustomAudioSource.m        | 141 ++++++++++
 .../custom_audio/custom_audio_source.dart     | 260 ++++++++++++++++++
 .../custom_audio/custom_audio_source_api.dart |  18 ++
 .../custom_audio_source_api.generated.dart    | 116 ++++++++
 example/lib/examples/advanced/index.dart      |   2 +
 example/pubspec.yaml                          |   1 +
 14 files changed, 1032 insertions(+)
 create mode 100644 example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioRecordService.java
 create mode 100644 example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioStatus.java
 create mode 100644 example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioPlugin.kt
 create mode 100644 example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioSource.java
 create mode 100644 example/ios/Runner/CustomAudioSource.h
 create mode 100644 example/ios/Runner/CustomAudioSource.m
 create mode 100644 example/lib/examples/advanced/custom_audio/custom_audio_source.dart
 create mode 100644 example/lib/examples/advanced/custom_audio/custom_audio_source_api.dart
 create mode 100644 example/lib/examples/advanced/custom_audio/custom_audio_source_api.generated.dart

diff --git a/example/android/app/build.gradle b/example/android/app/build.gradle
index bed57d628..6dea3dfea 100644
--- a/example/android/app/build.gradle
+++ b/example/android/app/build.gradle
@@ -28,6 +28,15 @@ apply from: "$flutterRoot/packages/flutter_tools/gradle/flutter.gradle"
 android {
     compileSdkVersion 28
 
+    compileOptions {
+      sourceCompatibility JavaVersion.VERSION_1_8
+      targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+      jvmTarget = '1.8'
+    }
+
     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'
         test.java.srcDirs += 'src/test/kotlin'
diff --git a/example/android/app/src/main/AndroidManifest.xml b/example/android/app/src/main/AndroidManifest.xml
index e9215f26c..107b7e977 100644
--- a/example/android/app/src/main/AndroidManifest.xml
+++ b/example/android/app/src/main/AndroidManifest.xml
@@ -1,6 +1,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="io.agora.agora_rtc_engine_example">
     <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
     <!-- io.flutter.app.FlutterApplication is an android.app.Application that
          calls FlutterMain.startInitialization(this); in its onCreate method.
          In most cases you can leave this as-is, but you if you want to provide
@@ -44,5 +45,9 @@
         <meta-data
             android:name="flutterEmbedding"
             android:value="2" />
+
+      <service
+        android:name="io.agora.agora_rtc_engine_example.custom_audio_source.AudioRecordService"
+        android:exported="false" />
     </application>
 </manifest>
diff --git a/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/MainActivity.kt b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/MainActivity.kt
index f0dfc6bad..e82cf4d19 100644
--- a/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/MainActivity.kt
+++ b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/MainActivity.kt
@@ -1,6 +1,31 @@
 package io.agora.agora_rtc_engine_example
 
+import android.os.Bundle
+import io.agora.agora_rtc_engine_example.custom_audio_source.CustomAudioPlugin
+import io.agora.agora_rtc_engine_example.custom_audio_source.CustomAudioSource
+import io.agora.rtc.base.RtcEnginePlugin
 import io.flutter.embedding.android.FlutterActivity
+import io.flutter.embedding.engine.FlutterEngine
+import java.lang.ref.WeakReference
 
 class MainActivity: FlutterActivity() {
+
+  private val customAudioPlugin = CustomAudioPlugin(WeakReference(this))
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    RtcEnginePlugin.register(customAudioPlugin)
+  }
+
+  override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
+    super.configureFlutterEngine(flutterEngine)
+    CustomAudioSource.CustomAudioSourceApi.setup(flutterEngine.dartExecutor, customAudioPlugin)
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+
+    RtcEnginePlugin.unregister(customAudioPlugin)
+  }
 }
diff --git a/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioRecordService.java b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioRecordService.java
new file mode 100644
index 000000000..3c3eb63c8
--- /dev/null
+++ b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioRecordService.java
@@ -0,0 +1,195 @@
+package io.agora.agora_rtc_engine_example.custom_audio_source;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.media.AudioFormat;
+import android.media.AudioRecord;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.os.IBinder;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+
+
+public class AudioRecordService extends Service
+{
+    private static final String TAG = AudioRecordService.class.getSimpleName();
+
+  private volatile boolean stopped;
+    private int mSampleRate;
+    private int mChannels;
+
+    public static void start(
+      Context context,
+      Class<?> notificationActivity,
+      int sampleRate,
+      int channels
+    ) {
+      Intent intent = new Intent(context, AudioRecordService.class);
+      intent.putExtra("notificationActivity", notificationActivity);
+      intent.putExtra("sampleRate", sampleRate);
+      intent.putExtra("channels", channels);
+      context.startService(intent);
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent)
+    {
+        return null;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        mSampleRate = intent.getIntExtra("sampleRate", -1);
+        mChannels = intent.getIntExtra("channels", -1);
+        startForeground((Class<?>) intent.getSerializableExtra("notificationActivity"));
+        startRecording();
+        return Service.START_STICKY;
+    }
+
+    private void startForeground(Class<?> clazz)
+    {
+        createNotificationChannel();
+        Intent notificationIntent = new Intent(this, clazz);
+        PendingIntent pendingIntent = PendingIntent.getActivity(this,
+                0, notificationIntent, 0);
+
+        Notification notification = new NotificationCompat.Builder(this, TAG)
+                .setContentTitle(TAG)
+                .setContentIntent(pendingIntent)
+                .build();
+
+        startForeground(1, notification);
+    }
+
+    private void createNotificationChannel()
+    {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+        {
+            NotificationChannel serviceChannel = new NotificationChannel(
+                    TAG, TAG, NotificationManager.IMPORTANCE_DEFAULT
+            );
+
+            NotificationManager manager = getSystemService(NotificationManager.class);
+            manager.createNotificationChannel(serviceChannel);
+        }
+    }
+
+    private void startRecording() {
+      RecordThread thread = new RecordThread();
+      thread.start();
+    }
+
+    private void stopRecording()
+    {
+        stopped = true;
+    }
+
+    @Override
+    public void onDestroy()
+    {
+        stopRecording();
+        super.onDestroy();
+    }
+
+    private void sendData(byte[] buffer) {
+      Intent intent = new Intent("AudioRecordRead");
+      intent.putExtra("buffer", buffer);
+      intent.putExtra("sampleRate", mSampleRate);
+      intent.putExtra("channels", mChannels);
+      sendBroadcast(intent);
+    }
+
+    public class RecordThread extends Thread
+    {
+        private final AudioRecord audioRecord;
+        private static final int DEFAULT_CHANNEL_CONFIG = AudioFormat.CHANNEL_IN_MONO;
+        private byte[] buffer;
+
+        RecordThread()
+        {
+            int bufferSize = AudioRecord.getMinBufferSize(mSampleRate, DEFAULT_CHANNEL_CONFIG,
+                    AudioFormat.ENCODING_PCM_16BIT);
+            audioRecord = new AudioRecord(
+              MediaRecorder.AudioSource.MIC,
+              mSampleRate,
+              mChannels,
+              AudioFormat.ENCODING_PCM_16BIT, bufferSize);
+
+            buffer = new byte[bufferSize];
+        }
+
+        @Override
+        public void run()
+        {
+            try
+            {
+                audioRecord.startRecording();
+                while (!stopped)
+                {
+                    int result = audioRecord.read(buffer, 0, buffer.length);
+                    if (result >= 0)
+                    {
+                        /**Pushes the external audio frame to the Agora SDK for encoding.
+                         * @param data External audio data to be pushed.
+                         * @param timeStamp Timestamp of the external audio frame. It is mandatory.
+                         *                  You can use this parameter for the following purposes:
+                         *                    1:Restore the order of the captured audio frame.
+                         *                    2:Synchronize audio and video frames in video-related
+                         *                      scenarios, including scenarios where external video sources are used.
+                         * @return
+                         *   0: Success.
+                         *   < 0: Failure.*/
+                      sendData(buffer);
+                    }
+                    else
+                    {
+                        logRecordError(result);
+                    }
+                    Log.d(TAG, "byte size is :" + result);
+                }
+                release();
+            }
+            catch (Exception e)
+            {e.printStackTrace();}
+        }
+
+        private void logRecordError(int error)
+        {
+            String message = "";
+            switch (error)
+            {
+                case AudioRecord.ERROR:
+                    message = "generic operation failure";
+                    break;
+                case AudioRecord.ERROR_BAD_VALUE:
+                    message = "failure due to the use of an invalid value";
+                    break;
+                case AudioRecord.ERROR_DEAD_OBJECT:
+                    message = "object is no longer valid and needs to be recreated";
+                    break;
+                case AudioRecord.ERROR_INVALID_OPERATION:
+                    message = "failure due to the improper use of method";
+                    break;
+            }
+            Log.e(TAG, message);
+        }
+
+        private void release()
+        {
+            if (audioRecord != null)
+            {
+                audioRecord.stop();
+                buffer = null;
+            }
+        }
+    }
+}
diff --git a/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioStatus.java b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioStatus.java
new file mode 100644
index 000000000..585f76699
--- /dev/null
+++ b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/AudioStatus.java
@@ -0,0 +1,7 @@
+package io.agora.agora_rtc_engine_example.custom_audio_source;
+
+public enum AudioStatus {
+    INITIALISING,
+    RUNNING,
+    STOPPED
+}
diff --git a/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioPlugin.kt b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioPlugin.kt
new file mode 100644
index 000000000..04e2a9997
--- /dev/null
+++ b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioPlugin.kt
@@ -0,0 +1,73 @@
+package io.agora.agora_rtc_engine_example.custom_audio_source
+
+import android.app.Activity
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioFormat
+import io.agora.rtc.Constants
+import io.agora.rtc.RtcEngine
+import io.agora.rtc.base.RtcEnginePlugin
+import java.lang.ref.WeakReference
+
+class CustomAudioPlugin(private val activity: WeakReference<Activity>) :
+  RtcEnginePlugin,
+  CustomAudioSource.CustomAudioSourceApi {
+
+  private var rtcEngine: RtcEngine? = null
+
+  @Volatile
+  private var sourcePos: Int = Constants.AudioExternalSourcePos.getValue(
+    Constants.AudioExternalSourcePos.AUDIO_EXTERNAL_PLAYOUT_SOURCE)
+
+  private val broadcastReceiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+      intent?.apply {
+        val buffer = getByteArrayExtra("buffer")
+        val sampleRate = getIntExtra("sampleRate", -1)
+        val channels = getIntExtra("channels", -1)
+
+        rtcEngine?.pushExternalAudioFrame(
+          buffer,
+          System.currentTimeMillis(),
+          sampleRate,
+          channels,
+          AudioFormat.ENCODING_PCM_16BIT,
+          sourcePos)
+      }
+    }
+  }
+
+  override fun onRtcEngineCreated(rtcEngine: RtcEngine?) {
+    this.rtcEngine = rtcEngine
+    activity.get()?.registerReceiver(broadcastReceiver, IntentFilter("AudioRecordRead"))
+  }
+
+  override fun onRtcEngineDestroyed() {
+    activity.get()?.unregisterReceiver(broadcastReceiver)
+    rtcEngine = null
+  }
+
+  override fun setExternalAudioSource(enabled: Boolean?, sampleRate: Long?, channels: Long?) {
+    rtcEngine?.setExternalAudioSource(enabled!!, sampleRate!!.toInt(), channels!!.toInt())
+  }
+
+  override fun setExternalAudioSourceVolume(sourcePos: Long?, volume: Long?) {
+    this.sourcePos = sourcePos!!.toInt()
+    rtcEngine?.setExternalAudioSourceVolume(this.sourcePos, volume!!.toInt())
+  }
+
+  override fun startAudioRecord(sampleRate: Long?, channels: Long?) {
+    activity.get()?.apply {
+      AudioRecordService.start(this, this::class.java, sampleRate!!.toInt(), channels!!.toInt())
+    }
+  }
+
+  override fun stopAudioRecord() {
+    activity.get()?.apply {
+      val intent = Intent(this, AudioRecordService::class.java)
+      stopService(intent)
+    }
+  }
+}
diff --git a/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioSource.java b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioSource.java
new file mode 100644
index 000000000..7187e865b
--- /dev/null
+++ b/example/android/app/src/main/kotlin/io/agora/agora_rtc_engine_example/custom_audio_source/CustomAudioSource.java
@@ -0,0 +1,156 @@
+// Autogenerated from Pigeon (v1.0.7), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+
+package io.agora.agora_rtc_engine_example.custom_audio_source;
+
+import io.flutter.plugin.common.BasicMessageChannel;
+import io.flutter.plugin.common.BinaryMessenger;
+import io.flutter.plugin.common.MessageCodec;
+import io.flutter.plugin.common.StandardMessageCodec;
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+/** Generated class from Pigeon. */
+@SuppressWarnings({"unused", "unchecked", "CodeBlock2Expr", "RedundantSuppression"})
+public class CustomAudioSource {
+  private static class CustomAudioSourceApiCodec extends StandardMessageCodec {
+    public static final CustomAudioSourceApiCodec INSTANCE = new CustomAudioSourceApiCodec();
+    private CustomAudioSourceApiCodec() {}
+  }
+
+  /** Generated interface from Pigeon that represents a handler of messages from Flutter.*/
+  public interface CustomAudioSourceApi {
+    void setExternalAudioSource(Boolean enabled, Long sampleRate, Long channels);
+    void setExternalAudioSourceVolume(Long sourcePos, Long volume);
+    void startAudioRecord(Long sampleRate, Long channels);
+    void stopAudioRecord();
+
+    /** The codec used by CustomAudioSourceApi. */
+    static MessageCodec<Object> getCodec() {
+      return CustomAudioSourceApiCodec.INSTANCE;
+    }
+
+    /** Sets up an instance of `CustomAudioSourceApi` to handle messages through the `binaryMessenger`. */
+    static void setup(BinaryMessenger binaryMessenger, CustomAudioSourceApi api) {
+      {
+        BasicMessageChannel<Object> channel =
+            new BasicMessageChannel<>(binaryMessenger, "dev.flutter.pigeon.CustomAudioSourceApi.setExternalAudioSource", getCodec());
+        if (api != null) {
+          channel.setMessageHandler((message, reply) -> {
+            Map<String, Object> wrapped = new HashMap<>();
+            try {
+              ArrayList<Object> args = (ArrayList<Object>)message;
+              Boolean enabledArg = (Boolean)args.get(0);
+              if (enabledArg == null) {
+                throw new NullPointerException("enabledArg unexpectedly null.");
+              }
+              Number sampleRateArg = (Number)args.get(1);
+              if (sampleRateArg == null) {
+                throw new NullPointerException("sampleRateArg unexpectedly null.");
+              }
+              Number channelsArg = (Number)args.get(2);
+              if (channelsArg == null) {
+                throw new NullPointerException("channelsArg unexpectedly null.");
+              }
+              api.setExternalAudioSource(enabledArg, sampleRateArg.longValue(), channelsArg.longValue());
+              wrapped.put("result", null);
+            }
+            catch (Error | RuntimeException exception) {
+              wrapped.put("error", wrapError(exception));
+            }
+            reply.reply(wrapped);
+          });
+        } else {
+          channel.setMessageHandler(null);
+        }
+      }
+      {
+        BasicMessageChannel<Object> channel =
+            new BasicMessageChannel<>(binaryMessenger, "dev.flutter.pigeon.CustomAudioSourceApi.setExternalAudioSourceVolume", getCodec());
+        if (api != null) {
+          channel.setMessageHandler((message, reply) -> {
+            Map<String, Object> wrapped = new HashMap<>();
+            try {
+              ArrayList<Object> args = (ArrayList<Object>)message;
+              Number sourcePosArg = (Number)args.get(0);
+              if (sourcePosArg == null) {
+                throw new NullPointerException("sourcePosArg unexpectedly null.");
+              }
+              Number volumeArg = (Number)args.get(1);
+              if (volumeArg == null) {
+                throw new NullPointerException("volumeArg unexpectedly null.");
+              }
+              api.setExternalAudioSourceVolume(sourcePosArg.longValue(), volumeArg.longValue());
+              wrapped.put("result", null);
+            }
+            catch (Error | RuntimeException exception) {
+              wrapped.put("error", wrapError(exception));
+            }
+            reply.reply(wrapped);
+          });
+        } else {
+          channel.setMessageHandler(null);
+        }
+      }
+      {
+        BasicMessageChannel<Object> channel =
+            new BasicMessageChannel<>(binaryMessenger, "dev.flutter.pigeon.CustomAudioSourceApi.startAudioRecord", getCodec());
+        if (api != null) {
+          channel.setMessageHandler((message, reply) -> {
+            Map<String, Object> wrapped = new HashMap<>();
+            try {
+              ArrayList<Object> args = (ArrayList<Object>)message;
+              Number sampleRateArg = (Number)args.get(0);
+              if (sampleRateArg == null) {
+                throw new NullPointerException("sampleRateArg unexpectedly null.");
+              }
+              Number channelsArg = (Number)args.get(1);
+              if (channelsArg == null) {
+                throw new NullPointerException("channelsArg unexpectedly null.");
+              }
+              api.startAudioRecord(sampleRateArg.longValue(), channelsArg.longValue());
+              wrapped.put("result", null);
+            }
+            catch (Error | RuntimeException exception) {
+              wrapped.put("error", wrapError(exception));
+            }
+            reply.reply(wrapped);
+          });
+        } else {
+          channel.setMessageHandler(null);
+        }
+      }
+      {
+        BasicMessageChannel<Object> channel =
+            new BasicMessageChannel<>(binaryMessenger, "dev.flutter.pigeon.CustomAudioSourceApi.stopAudioRecord", getCodec());
+        if (api != null) {
+          channel.setMessageHandler((message, reply) -> {
+            Map<String, Object> wrapped = new HashMap<>();
+            try {
+              api.stopAudioRecord();
+              wrapped.put("result", null);
+            }
+            catch (Error | RuntimeException exception) {
+              wrapped.put("error", wrapError(exception));
+            }
+            reply.reply(wrapped);
+          });
+        } else {
+          channel.setMessageHandler(null);
+        }
+      }
+    }
+  }
+  private static Map<String, Object> wrapError(Throwable exception) {
+    Map<String, Object> errorMap = new HashMap<>();
+    errorMap.put("message", exception.toString());
+    errorMap.put("code", exception.getClass().getSimpleName());
+    errorMap.put("details", null);
+    return errorMap;
+  }
+}
diff --git a/example/ios/Runner/CustomAudioSource.h b/example/ios/Runner/CustomAudioSource.h
new file mode 100644
index 000000000..100e08867
--- /dev/null
+++ b/example/ios/Runner/CustomAudioSource.h
@@ -0,0 +1,24 @@
+// Autogenerated from Pigeon (v1.0.7), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+#import <Foundation/Foundation.h>
+@protocol FlutterBinaryMessenger;
+@protocol FlutterMessageCodec;
+@class FlutterError;
+@class FlutterStandardTypedData;
+
+NS_ASSUME_NONNULL_BEGIN
+
+
+/// The codec used by CustomAudioSourceApi.
+NSObject<FlutterMessageCodec> *CustomAudioSourceApiGetCodec(void);
+
+@protocol CustomAudioSourceApi
+- (void)setExternalAudioSourceEnabled:(NSNumber *)enabled sampleRate:(NSNumber *)sampleRate channels:(NSNumber *)channels error:(FlutterError *_Nullable *_Nonnull)error;
+- (void)setExternalAudioSourceVolumeSourcePos:(NSNumber *)sourcePos volume:(NSNumber *)volume error:(FlutterError *_Nullable *_Nonnull)error;
+- (void)startAudioRecordSampleRate:(NSNumber *)sampleRate channels:(NSNumber *)channels error:(FlutterError *_Nullable *_Nonnull)error;
+- (void)stopAudioRecordWithError:(FlutterError *_Nullable *_Nonnull)error;
+@end
+
+extern void CustomAudioSourceApiSetup(id<FlutterBinaryMessenger> binaryMessenger, NSObject<CustomAudioSourceApi> *_Nullable api);
+
+NS_ASSUME_NONNULL_END
diff --git a/example/ios/Runner/CustomAudioSource.m b/example/ios/Runner/CustomAudioSource.m
new file mode 100644
index 000000000..573fd6e9e
--- /dev/null
+++ b/example/ios/Runner/CustomAudioSource.m
@@ -0,0 +1,141 @@
+// Autogenerated from Pigeon (v1.0.7), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+#import "CustomAudioSource.h"
+#import <Flutter/Flutter.h>
+
+#if !__has_feature(objc_arc)
+#error File requires ARC to be enabled.
+#endif
+
+static NSDictionary<NSString *, id> *wrapResult(id result, FlutterError *error) {
+  NSDictionary *errorDict = (NSDictionary *)[NSNull null];
+  if (error) {
+    errorDict = @{
+        @"code": (error.code ? error.code : [NSNull null]),
+        @"message": (error.message ? error.message : [NSNull null]),
+        @"details": (error.details ? error.details : [NSNull null]),
+        };
+  }
+  return @{
+      @"result": (result ? result : [NSNull null]),
+      @"error": errorDict,
+      };
+}
+
+
+@interface CustomAudioSourceApiCodecReader : FlutterStandardReader
+@end
+@implementation CustomAudioSourceApiCodecReader
+@end
+
+@interface CustomAudioSourceApiCodecWriter : FlutterStandardWriter
+@end
+@implementation CustomAudioSourceApiCodecWriter
+@end
+
+@interface CustomAudioSourceApiCodecReaderWriter : FlutterStandardReaderWriter
+@end
+@implementation CustomAudioSourceApiCodecReaderWriter
+- (FlutterStandardWriter *)writerWithData:(NSMutableData *)data {
+  return [[CustomAudioSourceApiCodecWriter alloc] initWithData:data];
+}
+- (FlutterStandardReader *)readerWithData:(NSData *)data {
+  return [[CustomAudioSourceApiCodecReader alloc] initWithData:data];
+}
+@end
+
+NSObject<FlutterMessageCodec> *CustomAudioSourceApiGetCodec() {
+  static dispatch_once_t s_pred = 0;
+  static FlutterStandardMessageCodec *s_sharedObject = nil;
+  dispatch_once(&s_pred, ^{
+    CustomAudioSourceApiCodecReaderWriter *readerWriter = [[CustomAudioSourceApiCodecReaderWriter alloc] init];
+    s_sharedObject = [FlutterStandardMessageCodec codecWithReaderWriter:readerWriter];
+  });
+  return s_sharedObject;
+}
+
+
+void CustomAudioSourceApiSetup(id<FlutterBinaryMessenger> binaryMessenger, NSObject<CustomAudioSourceApi> *api) {
+  {
+    FlutterBasicMessageChannel *channel =
+      [FlutterBasicMessageChannel
+        messageChannelWithName:@"dev.flutter.pigeon.CustomAudioSourceApi.setExternalAudioSource"
+        binaryMessenger:binaryMessenger
+        codec:CustomAudioSourceApiGetCodec()];
+    if (api) {
+      NSCAssert([api respondsToSelector:@selector(setExternalAudioSourceEnabled:sampleRate:channels:error:)], @"CustomAudioSourceApi api (%@) doesn't respond to @selector(setExternalAudioSourceEnabled:sampleRate:channels:error:)", api);
+      [channel setMessageHandler:^(id _Nullable message, FlutterReply callback) {
+        NSArray *args = message;
+        NSNumber *arg_enabled = args[0];
+        NSNumber *arg_sampleRate = args[1];
+        NSNumber *arg_channels = args[2];
+        FlutterError *error;
+        [api setExternalAudioSourceEnabled:arg_enabled sampleRate:arg_sampleRate channels:arg_channels error:&error];
+        callback(wrapResult(nil, error));
+      }];
+    }
+    else {
+      [channel setMessageHandler:nil];
+    }
+  }
+  {
+    FlutterBasicMessageChannel *channel =
+      [FlutterBasicMessageChannel
+        messageChannelWithName:@"dev.flutter.pigeon.CustomAudioSourceApi.setExternalAudioSourceVolume"
+        binaryMessenger:binaryMessenger
+        codec:CustomAudioSourceApiGetCodec()];
+    if (api) {
+      NSCAssert([api respondsToSelector:@selector(setExternalAudioSourceVolumeSourcePos:volume:error:)], @"CustomAudioSourceApi api (%@) doesn't respond to @selector(setExternalAudioSourceVolumeSourcePos:volume:error:)", api);
+      [channel setMessageHandler:^(id _Nullable message, FlutterReply callback) {
+        NSArray *args = message;
+        NSNumber *arg_sourcePos = args[0];
+        NSNumber *arg_volume = args[1];
+        FlutterError *error;
+        [api setExternalAudioSourceVolumeSourcePos:arg_sourcePos volume:arg_volume error:&error];
+        callback(wrapResult(nil, error));
+      }];
+    }
+    else {
+      [channel setMessageHandler:nil];
+    }
+  }
+  {
+    FlutterBasicMessageChannel *channel =
+      [FlutterBasicMessageChannel
+        messageChannelWithName:@"dev.flutter.pigeon.CustomAudioSourceApi.startAudioRecord"
+        binaryMessenger:binaryMessenger
+        codec:CustomAudioSourceApiGetCodec()];
+    if (api) {
+      NSCAssert([api respondsToSelector:@selector(startAudioRecordSampleRate:channels:error:)], @"CustomAudioSourceApi api (%@) doesn't respond to @selector(startAudioRecordSampleRate:channels:error:)", api);
+      [channel setMessageHandler:^(id _Nullable message, FlutterReply callback) {
+        NSArray *args = message;
+        NSNumber *arg_sampleRate = args[0];
+        NSNumber *arg_channels = args[1];
+        FlutterError *error;
+        [api startAudioRecordSampleRate:arg_sampleRate channels:arg_channels error:&error];
+        callback(wrapResult(nil, error));
+      }];
+    }
+    else {
+      [channel setMessageHandler:nil];
+    }
+  }
+  {
+    FlutterBasicMessageChannel *channel =
+      [FlutterBasicMessageChannel
+        messageChannelWithName:@"dev.flutter.pigeon.CustomAudioSourceApi.stopAudioRecord"
+        binaryMessenger:binaryMessenger
+        codec:CustomAudioSourceApiGetCodec()];
+    if (api) {
+      NSCAssert([api respondsToSelector:@selector(stopAudioRecordWithError:)], @"CustomAudioSourceApi api (%@) doesn't respond to @selector(stopAudioRecordWithError:)", api);
+      [channel setMessageHandler:^(id _Nullable message, FlutterReply callback) {
+        FlutterError *error;
+        [api stopAudioRecordWithError:&error];
+        callback(wrapResult(nil, error));
+      }];
+    }
+    else {
+      [channel setMessageHandler:nil];
+    }
+  }
+}
diff --git a/example/lib/examples/advanced/custom_audio/custom_audio_source.dart b/example/lib/examples/advanced/custom_audio/custom_audio_source.dart
new file mode 100644
index 000000000..ea1e36f79
--- /dev/null
+++ b/example/lib/examples/advanced/custom_audio/custom_audio_source.dart
@@ -0,0 +1,260 @@
+import 'package:agora_rtc_engine/rtc_engine.dart';
+import 'package:agora_rtc_engine_example/config/agora.config.dart' as config;
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/widgets.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+import 'custom_audio_source_api.generated.dart';
+
+const int _defaultSampleRate = 16000;
+const int _defaultChannelCount = 1;
+
+/// The push position of the external audio frame. see [Android API reference](https://docs.agora.io/en/Voice/API%20Reference/java/enumio_1_1agora_1_1rtc_1_1_constants_1_1_audio_external_source_pos.html).
+enum AudioExternalSourcePos {
+  /// 0: The position before local playback. If you need to play the external audio
+  /// frame on the local client, set this position.
+  externalPlayoutSource,
+
+  /// 1: The position after audio capture and before audio pre-processing. If you
+  /// need the audio module of the SDK to process the external audio frame, set
+  /// this position.
+  externalRecordSourcePreProcess,
+
+  /// 2: The position after audio pre-processing and before audio encoding. If
+  /// you do not need the audio module of the SDK to process the external audio
+  /// frame, set this position.
+  externalRecordSourcePostProcess
+}
+
+/// Extension for AudioExternalSourcePos
+extension AudioExternalSourcePosExt on AudioExternalSourcePos {
+  /// Get int value acroding the AudioExternalSourcePos value
+  int get value {
+    switch (this) {
+      case AudioExternalSourcePos.externalPlayoutSource:
+        return 0;
+      case AudioExternalSourcePos.externalRecordSourcePreProcess:
+        return 1;
+      case AudioExternalSourcePos.externalRecordSourcePostProcess:
+        return 2;
+    }
+  }
+}
+
+/// CustomAudioSource Example
+class CustomAudioSource extends StatefulWidget {
+  @override
+  _CustomAudioSourceState createState() => _CustomAudioSourceState();
+}
+
+class _CustomAudioSourceState extends State<CustomAudioSource> {
+  final CustomAudioSourceApi _api = CustomAudioSourceApi();
+  bool _isJoined = false;
+  bool _isMute = false;
+  double _playoutSliderValue = 100.0;
+  double _preProcessSliderValue = 100.0;
+  double _postProcessSliderValue = 100.0;
+  AudioExternalSourcePos _audioExternalSourcePos =
+      AudioExternalSourcePos.externalPlayoutSource;
+  late final RtcEngine _engine;
+
+  @override
+  void initState() {
+    super.initState();
+    _initEngine();
+  }
+
+  @override
+  void dispose() {
+    super.dispose();
+    _destroyEngine();
+  }
+
+  void _initEngine() async {
+    _engine = await RtcEngine.createWithContext(RtcEngineContext(config.appId));
+
+    _engine.setEventHandler(RtcEngineEventHandler(
+      joinChannelSuccess: (String channel, int uid, int elapsed) async {
+        await _api.startAudioRecord(_defaultSampleRate, _defaultChannelCount);
+        setState(() {
+          _isJoined = true;
+        });
+      },
+    ));
+  }
+
+  void _joinChannel() async {
+    if (Theme.of(context).platform == TargetPlatform.android) {
+      await Permission.microphone.request();
+    }
+
+    // make this room live broadcasting room
+    await _engine.setChannelProfile(ChannelProfile.LiveBroadcasting);
+    await _engine.setClientRole(ClientRole.Broadcaster);
+
+    await _engine.setDefaultAudioRoutetoSpeakerphone(true);
+
+    // Sets the external audio source.
+    // PS: Ensure that you call this method before the joinChannel method
+    await _api.setExternalAudioSource(
+        true, _defaultSampleRate, _defaultChannelCount);
+
+    // Set audio route to speaker
+    await _engine.setDefaultAudioRoutetoSpeakerphone(true);
+
+    final option = ChannelMediaOptions();
+    option.autoSubscribeAudio = true;
+    option.autoSubscribeVideo = false;
+
+    // start joining channel
+    // 1. Users can only see each other after they join the
+    // same channel successfully using the same app id.
+    // 2. If app certificate is turned on at dashboard, token is needed
+    // when joining channel. The channel name and uid used to calculate
+    // the token has to match the ones used for channel join
+    await _engine.joinChannel(config.token, config.channelId, null, 0, option);
+  }
+
+  void _destroyEngine() {
+    _api.stopAudioRecord();
+    _engine.leaveChannel();
+    _engine.destroy();
+  }
+
+  void _sourcePosChanged() {
+    var volume = 0;
+    switch (_audioExternalSourcePos) {
+      case AudioExternalSourcePos.externalPlayoutSource:
+        volume = _playoutSliderValue.toInt();
+        break;
+      case AudioExternalSourcePos.externalRecordSourcePreProcess:
+        volume = _preProcessSliderValue.toInt();
+        break;
+      case AudioExternalSourcePos.externalRecordSourcePostProcess:
+        volume = _postProcessSliderValue.toInt();
+        break;
+    }
+    _api.setExternalAudioSourceVolume(
+      _audioExternalSourcePos.value,
+      volume,
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      child: Column(
+        mainAxisAlignment: MainAxisAlignment.start,
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          ElevatedButton(
+            onPressed: !_isJoined ? _joinChannel : null,
+            child: Text('Join Channel'),
+          ),
+          if (_isJoined) ...[
+            ListTile(
+              title: Row(
+                children: [
+                  const Text('PlayOut'),
+                  Expanded(
+                    child: Slider(
+                      value: _playoutSliderValue,
+                      min: 0,
+                      max: 100,
+                      label: _playoutSliderValue.round().toString(),
+                      onChanged: (double value) {
+                        _playoutSliderValue = value;
+                        _sourcePosChanged();
+                        setState(() {});
+                      },
+                    ),
+                  )
+                ],
+              ),
+              leading: Radio<AudioExternalSourcePos>(
+                value: AudioExternalSourcePos.externalPlayoutSource,
+                groupValue: _audioExternalSourcePos,
+                onChanged: (AudioExternalSourcePos? value) {
+                  _audioExternalSourcePos = value!;
+                  _sourcePosChanged();
+                  setState(() {});
+                },
+              ),
+            ),
+            ListTile(
+              title: Row(
+                children: [
+                  const Text('PreProcess'),
+                  Expanded(
+                    child: Slider(
+                      value: _preProcessSliderValue,
+                      min: 0,
+                      max: 100,
+                      divisions: 100,
+                      label: _preProcessSliderValue.round().toString(),
+                      onChanged: (double value) {
+                        _preProcessSliderValue = value;
+                        _sourcePosChanged();
+                        setState(() {});
+                      },
+                    ),
+                  )
+                ],
+              ),
+              leading: Radio<AudioExternalSourcePos>(
+                value: AudioExternalSourcePos.externalRecordSourcePreProcess,
+                groupValue: _audioExternalSourcePos,
+                onChanged: (AudioExternalSourcePos? value) {
+                  _audioExternalSourcePos = value!;
+                  _sourcePosChanged();
+                  setState(() {});
+                },
+              ),
+            ),
+            ListTile(
+              title: Row(
+                children: [
+                  const Text('PostProcess'),
+                  Expanded(
+                    child: Slider(
+                      value: _postProcessSliderValue,
+                      min: 0,
+                      max: 100,
+                      label: _postProcessSliderValue.round().toString(),
+                      onChanged: (double value) {
+                        _postProcessSliderValue = value;
+
+                        _sourcePosChanged();
+                        setState(() {});
+                      },
+                    ),
+                  )
+                ],
+              ),
+              leading: Radio<AudioExternalSourcePos>(
+                value: AudioExternalSourcePos.externalRecordSourcePostProcess,
+                groupValue: _audioExternalSourcePos,
+                onChanged: (AudioExternalSourcePos? value) {
+                  _audioExternalSourcePos = value!;
+                  _sourcePosChanged();
+                  setState(() {});
+                },
+              ),
+            ),
+            ElevatedButton(
+              onPressed: !_isJoined
+                  ? null
+                  : () async {
+                      _isMute = !_isMute;
+                      await _engine.muteLocalAudioStream(_isMute);
+                      setState(() {});
+                    },
+              child: Text('${_isMute ? 'Open' : 'Mute'} microphone'),
+            ),
+          ],
+        ],
+      ),
+    );
+  }
+}
diff --git a/example/lib/examples/advanced/custom_audio/custom_audio_source_api.dart b/example/lib/examples/advanced/custom_audio/custom_audio_source_api.dart
new file mode 100644
index 000000000..7f97a2b76
--- /dev/null
+++ b/example/lib/examples/advanced/custom_audio/custom_audio_source_api.dart
@@ -0,0 +1,18 @@
+import 'package:pigeon/pigeon.dart';
+
+/// CustomAudioSource API definition
+@HostApi()
+abstract class CustomAudioSourceApi {
+
+  /// A binding function for setExternalAudioSource on Android/iOS
+  void setExternalAudioSource(bool enabled, int sampleRate, int channels);
+
+  /// A binding function for setExternalAudioSourceVolume on Android/iOS
+  void setExternalAudioSourceVolume(int sourcePos, int volume);
+
+  /// Record external audio and push using pushExternalAudioFrame on Android/iOS
+  void startAudioRecord(int sampleRate, int channels);
+
+  /// Stop record audio
+  void stopAudioRecord();
+}
diff --git a/example/lib/examples/advanced/custom_audio/custom_audio_source_api.generated.dart b/example/lib/examples/advanced/custom_audio/custom_audio_source_api.generated.dart
new file mode 100644
index 000000000..7a710a1d3
--- /dev/null
+++ b/example/lib/examples/advanced/custom_audio/custom_audio_source_api.generated.dart
@@ -0,0 +1,116 @@
+// Autogenerated from Pigeon (v1.0.7), do not edit directly.
+// See also: https://pub.dev/packages/pigeon
+// ignore_for_file: public_member_api_docs, non_constant_identifier_names, avoid_as, unused_import, unnecessary_parenthesis, prefer_null_aware_operators, omit_local_variable_types, unused_shown_name
+// @dart = 2.12
+import 'dart:async';
+import 'dart:typed_data' show Uint8List, Int32List, Int64List, Float64List;
+
+import 'package:flutter/foundation.dart' show WriteBuffer, ReadBuffer;
+import 'package:flutter/services.dart';
+
+class _CustomAudioSourceApiCodec extends StandardMessageCodec {
+  const _CustomAudioSourceApiCodec();
+}
+
+class CustomAudioSourceApi {
+  /// Constructor for [CustomAudioSourceApi].  The [binaryMessenger] named argument is
+  /// available for dependency injection.  If it is left null, the default
+  /// BinaryMessenger will be used which routes to the host platform.
+  CustomAudioSourceApi({BinaryMessenger? binaryMessenger}) : _binaryMessenger = binaryMessenger;
+
+  final BinaryMessenger? _binaryMessenger;
+
+  static const MessageCodec<Object?> codec = _CustomAudioSourceApiCodec();
+
+  Future<void> setExternalAudioSource(bool arg_enabled, int arg_sampleRate, int arg_channels) async {
+    final BasicMessageChannel<Object?> channel = BasicMessageChannel<Object?>(
+        'dev.flutter.pigeon.CustomAudioSourceApi.setExternalAudioSource', codec, binaryMessenger: _binaryMessenger);
+    final Map<Object?, Object?>? replyMap =
+        await channel.send(<Object>[arg_enabled, arg_sampleRate, arg_channels]) as Map<Object?, Object?>?;
+    if (replyMap == null) {
+      throw PlatformException(
+        code: 'channel-error',
+        message: 'Unable to establish connection on channel.',
+        details: null,
+      );
+    } else if (replyMap['error'] != null) {
+      final Map<Object?, Object?> error = (replyMap['error'] as Map<Object?, Object?>?)!;
+      throw PlatformException(
+        code: (error['code'] as String?)!,
+        message: error['message'] as String?,
+        details: error['details'],
+      );
+    } else {
+      return;
+    }
+  }
+
+  Future<void> setExternalAudioSourceVolume(int arg_sourcePos, int arg_volume) async {
+    final BasicMessageChannel<Object?> channel = BasicMessageChannel<Object?>(
+        'dev.flutter.pigeon.CustomAudioSourceApi.setExternalAudioSourceVolume', codec, binaryMessenger: _binaryMessenger);
+    final Map<Object?, Object?>? replyMap =
+        await channel.send(<Object>[arg_sourcePos, arg_volume]) as Map<Object?, Object?>?;
+    if (replyMap == null) {
+      throw PlatformException(
+        code: 'channel-error',
+        message: 'Unable to establish connection on channel.',
+        details: null,
+      );
+    } else if (replyMap['error'] != null) {
+      final Map<Object?, Object?> error = (replyMap['error'] as Map<Object?, Object?>?)!;
+      throw PlatformException(
+        code: (error['code'] as String?)!,
+        message: error['message'] as String?,
+        details: error['details'],
+      );
+    } else {
+      return;
+    }
+  }
+
+  Future<void> startAudioRecord(int arg_sampleRate, int arg_channels) async {
+    final BasicMessageChannel<Object?> channel = BasicMessageChannel<Object?>(
+        'dev.flutter.pigeon.CustomAudioSourceApi.startAudioRecord', codec, binaryMessenger: _binaryMessenger);
+    final Map<Object?, Object?>? replyMap =
+        await channel.send(<Object>[arg_sampleRate, arg_channels]) as Map<Object?, Object?>?;
+    if (replyMap == null) {
+      throw PlatformException(
+        code: 'channel-error',
+        message: 'Unable to establish connection on channel.',
+        details: null,
+      );
+    } else if (replyMap['error'] != null) {
+      final Map<Object?, Object?> error = (replyMap['error'] as Map<Object?, Object?>?)!;
+      throw PlatformException(
+        code: (error['code'] as String?)!,
+        message: error['message'] as String?,
+        details: error['details'],
+      );
+    } else {
+      return;
+    }
+  }
+
+  Future<void> stopAudioRecord() async {
+    final BasicMessageChannel<Object?> channel = BasicMessageChannel<Object?>(
+        'dev.flutter.pigeon.CustomAudioSourceApi.stopAudioRecord', codec, binaryMessenger: _binaryMessenger);
+    final Map<Object?, Object?>? replyMap =
+        await channel.send(null) as Map<Object?, Object?>?;
+    if (replyMap == null) {
+      throw PlatformException(
+        code: 'channel-error',
+        message: 'Unable to establish connection on channel.',
+        details: null,
+      );
+    } else if (replyMap['error'] != null) {
+      final Map<Object?, Object?> error = (replyMap['error'] as Map<Object?, Object?>?)!;
+      throw PlatformException(
+        code: (error['code'] as String?)!,
+        message: error['message'] as String?,
+        details: error['details'],
+      );
+    } else {
+      return;
+    }
+  }
+}
diff --git a/example/lib/examples/advanced/index.dart b/example/lib/examples/advanced/index.dart
index d7ebf6c27..555b8a079 100644
--- a/example/lib/examples/advanced/index.dart
+++ b/example/lib/examples/advanced/index.dart
@@ -1,4 +1,5 @@
 import 'package:agora_rtc_engine_example/examples/advanced/create_stream_data.dart';
+import 'package:agora_rtc_engine_example/examples/advanced/custom_audio/custom_audio_source.dart';
 import 'package:agora_rtc_engine_example/examples/advanced/live_streaming.dart';
 import 'package:agora_rtc_engine_example/examples/advanced/media_channel_relay.dart';
 import 'package:agora_rtc_engine_example/examples/advanced/multi_channel.dart';
@@ -18,4 +19,5 @@ final Advanced = [
     'widget': MediaChannelRelay(),
   },
   {'name': 'VoiceChange', 'widget': VoiceChange()},
+  {'name': 'CustomAudioSource', 'widget': CustomAudioSource()},
 ];
diff --git a/example/pubspec.yaml b/example/pubspec.yaml
index 5569ab163..4df9e79c1 100644
--- a/example/pubspec.yaml
+++ b/example/pubspec.yaml
@@ -33,6 +33,7 @@ dev_dependencies:
     sdk: flutter
   flutter_driver:
     sdk: flutter
+  pigeon: ^1.0.7
 
 # For information on the generic Dart part of this file, see the
 # following page: https://dart.dev/tools/pub/pubspec