1. Add directives in the app manifest and build.gradle

• Add this dependency to your build.gradle:

                  
                          implementation 'com.ntrack.audioroute:audioroute:1.0.1'
                  
          

• Add this line in the <manifest><application> section of your manifest file:

  		
  			<service android:name="com.ntrack.audioroute.AudioModuleForegroundService"></service>
  		
  	

  This is used by Audioroute to launch a foreground service for the app that will show a notification icon to make the hosted app activity remain active in the background when the user switches back to the host app or to other hosted apps.
  Optional: If you don't want Audioroute to automatically show the notification icon because you are already showing one call AudiorouteActivityController.setShowForegroundServiceNotification(false). But make sure your activity can't be destructed by the system when you are hosting Audioroute modules, otherwise unexpected behavior will occur.

• Add this line in the <manifest> section of your manifest file (required only if you set targetSdkVersion=28):

  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

• Make sure that your activity launch mode must be 'singleTop', 'singleTask' or 'singleInstance', in manifest:

  		
  			<activity android:name=".MainActivity"android:launchMode="singleTop" >
  		
  	

  'standard' launch mode is not currently supported.

2. Pass Activity events to Audioroute in your Activity class

• In your activity onCreate create an instance of AudiorouteActivityController and invoke it like this:

  
  	@Override
    protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      controller= AudiorouteActivityController.getInstance();
      controller.setModuleLabel("My app name");
      controller.setModuleImage(myAppIcon);
      controller.setListener(new AudiorouteActivityController.Listener() {
        @Override
        public void onRouteConnected() {
          // You're connected, update your UI etc.
        }
  
        @Override
        public void onRouteDisconnected() {
          // You're now disconnected
        }
  
        @Override
        public AudioModule createAudioModule() {
          return new MyAudiorouteModule();
        }
      });
      controller.onActivityCreated(this, false);
    }
    @Override
    protected void onResume()
    {
      super.onResume();
      controller.onResume();
    }
    @Override protected void onNewIntent (Intent intent)
    {
      super.onNewIntent(intent);
      controller.onNewIntent(intent);
    }
  

• Implement your subclass of AudioModule. Handle configure_module() and route it to your native code, which must register an audio callback:

  
  public class MyAppAudioModule extends AudioModule {
  private long my_native_resources = 0;
  
  @Override protected boolean configure_module(String name, long handle) {
      my_native_resources=configureNativeComponents(handle, channels);
  
      return my_native_resources!=0;
    }
  
    @Override
    protected void release() {
      if (my_native_resources != 0) {
        release(my_native_resources);
        my_native_resources = 0;
      }
    }
  
  private native long configureNativeComponents(long handle, int channels);
  
  private native void release(long native_resources_pointer);
  
  

3. Add native code process and initizialization callbacks

• Implement configureNativeComponents and pass to Audioroute your process and initialize callbacks in your native code:

  
  
  #include "path_where_you_cloned_sdk/AudioRouteSamples/audioroute/include/audio_module.h"
  		
  // My audio callback		
  static void process_func(void *context, int sample_rate, int framesPerBuffer,
       int input_channels, const float *input_buffer,
       int output_channels, float *output_buffer, MusicEvent *events, int eventsNum, int instance_index, struct AudiorouteTimeInfo *timeInfo) {
      my_native_data *data = (my_native_data *) context;
      int currentEvent=0;
      for(int i=0; i<framesPerBuffer; ++i) {
      	// Your audio processing here
      	...
  	}
  }
  
  // Audio processing initialization (called before the actual processing starts)
  // NOTE: the init_func may be called by an arbitrary thread. If you need to update UI inside this function make sure 
  // you invoke the code responsible for updating the UI in the UI thread
  static void init_func(void *context, int sample_rate, int framesPerBuffer, int instance_index, int connectedInputBuses[MaxNumBuses], int connectedOutputBuses[MaxNumBuses])
  {
  	// do your initialization stuff here, allocate resources based on sample_rate and framesPerBuffers etc.
  }
  
  // Tell Audioroute what your initialization and process callbacks are
  extern "C" JNIEXPORT jlong JNICALL
  Java_com_mycompany_myapp_MyAppAudioModule_configureNativeComponents
  (JNIEnv *env, jobject obj, jlong handle, jint channels) {
    my_native_data *data = (my_native_data *)malloc(sizeof(my_native_data));
    if (data) {
        audioroute_configure_java(env, obj, process_func, init_func, data);
    }
    return (jlong) data;
  }
  
  
  // Release data allocated when connected to Audioroute
  extern "C" JNIEXPORT void JNICALL
  Java_com_mycompany_myapp_MyAppAudioModule_release__J
  (JNIEnv *env, jobject obj, jlong p) {
    my_native_data *data = (my_native_data *) p;
    free(data);
  }
  
  

  Notice the inclusion of audio_module.h, you can find the file in the Audioroute SDK. Hosted apps don't need to link to the Audioroute native library libaudioroute.so. The lib is required only for host apps.
• After you've configured your module you'll receive a callback to your initialization callback and then callbacks to your process callback

4. Handle switch from audio device I/O to/from Audioroute

• After the connection is established you should stop or mute your normal audio I/O and only resume when the Audioroute connection is shut down (and your Activity is Resumed).
  When Audioroute is connected the AudiorouteActivityController.Listener listener you've passed to AudiorouteActivityController receives the onRouteConnected call. Inside the call do something like this:

  
  @Override public void onRouteConnected() {
  	new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
              stopAudioDevice();
              updateUI();
            }
          });
  }
  
  

  And when the app is disconnected restart the audio (after checking that the app is visible to the user, i.e. if the activity is not paused):

  
  @Override public void onRouteDisconnected() {
          //isAudiorouteConnected = false;
          new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
              showHostIcon(false);
              if(IsAppVisible()) 
  		startAudioDevice();
            }
          });
  }
  
  

• After you are connected to an Audioroute host, display somewhere in your UI an icon of the host app. You can get the icon drawable using the getHostIcon() method. When the icon is clicked switch to the host app with switchToHostApp().
• When the host closes the hosted app instance it will call AudioModule.release(). Use this call to free resources in your Java and native code. Audioroute will automatically shut down the foreground service and notification icon.

5. Handling MIDI

• If your app handles MIDI the host will send MusicEvent objects in your process callback, which should generate sounds corresponding to the input notes.
• The MusicEvent class support structured MIDI data, with high resolution (i.e. float) velocities and controllers. If your app already handles MIDI in the standard 4 bytes raw format, you can easily convert from MusicEvents to standard 32 bit words using ConvertMusicEventToRawMIDI().

6. Register the app in the Audioroute Developer Console

• For your app to appear in the list of available modules (even during development) inside an Audioroute host you must register the app in the Audioroute developer console
  You can use the app version number to tell Audioroute to show your app only when the device has the version of the app >= than the number entered in the dev console.

7. Test your app with an Audioroute compatible host

Currently available hosts include AudioRoute Sample Host and n-Track Studio