public class MainActivity extends AppCompatActivity
{
    static
    {
        System.loadLibrary("native-lib");
    }
}

class ActivityModel
{
public:
    void setMultiplier(int multiplier);
    int multiply(int a);
    static int multiply(int a, int b);
private:
    int _multiplier;
};

#include "ActivityModel.h"
void ActivityModel::setMultiplier(int multiplier)
{
    _multiplier = multiplier;
}
int ActivityModel::multiply(int a)
{
    return _multiplier * a;
}
int ActivityModel::multiply(int a, int b)
{
    return a * b;
}

// Module name (required)
%module SwigAndroidGuide
// Anything in the following section is added verbatim to the .cxx wrapper file
%{
#include "ActivityModel.h"
%}
// Process our C++ file (only the public section)
%include "ActivityModel.h"

#!/bin/bash
# cd to directory of this script.
# Note: don't need to go back - by exit this script, terminal will remain in the directory it currently is.
cd "$(dirname "$0")"
# Define various files and directories for script to work with.
generated_src_base_dir="../app/src/main"
generated_cpp_dir="${generated_src_base_dir}/cpp/swig-generated"
android_src_dir="${generated_src_base_dir}/cpp"
# Generated C++/JNI code goes into this file.
# This file is included into 'CMakeLists.txt'
generated_cpp_file="${generated_cpp_dir}/SwigAndroidGuide_wrap.cpp"
# Generated Java code goes into this directory.
generated_java_dir="${generated_src_base_dir}/java/com/goldberg/swigandroidguide/swiggenerated"
# Swig required already existing output directories.
# Delete all existing generated code and re-create directories.
rm -rf ${generated_cpp_dir}
rm -rf ${generated_java_dir}
mkdir -p ${generated_cpp_dir}
mkdir -p ${generated_java_dir}
# Run 'swig' tool.
#
# '-I' = include directory.
# '-c++ -java' - languages to create interface.
# '-package' defines Java package for generated code 'com.goldberg.swigandroidguide.swiggenerated'.
# '-o' - location of generated C++/JNI file.
# '-outdir' - location of generated Java code directory.
# 'SaveAndSpend.i' - script input file.
swig -I${android_src_dir} -c++ -java -package com.goldberg.swigandroidguide.swiggenerated -o ${generated_cpp_file} -outdir ${generated_java_dir} SwigAndroidGuide.i

# Our C++ code
AM app/src/main/cpp/ActivityModel.cpp
AM app/src/main/cpp/ActivityModel.h
# Our SWIG file and script
A  swig/SwigAndroidGuide.i
A  swig/run_swig.sh
# SWIG-generated Java code
A  app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/ActivityModel.java
# SWIG-generated helper code
A  app/src/main/cpp/swig-generated/SwigAndroidGuide_wrap.cpp
A  app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/SwigAndroidGuide.java
A  app/src/main/java/com/goldberg/swigandroidguide/swiggenerated/SwigAndroidGuideJNI.java

package com.goldberg.swigandroidguide.swiggenerated;
public class ActivityModel {
  //
  // This is SWIG helper code
  //
  private transient long swigCPtr;
  protected transient boolean swigCMemOwn;
  protected ActivityModel(long cPtr, boolean cMemoryOwn) {
    swigCMemOwn = cMemoryOwn;
    swigCPtr = cPtr;
  }
  protected static long getCPtr(ActivityModel obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }
  @SuppressWarnings("deprecation")
  protected void finalize() {
    delete();
  }
  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        SwigAndroidGuideJNI.delete_ActivityModel(swigCPtr);
      }
      swigCPtr = 0;
    }
  }
  //
  // Here is our C++ functions!
  //
  public void setMultiplier(int multiplier) {
    SwigAndroidGuideJNI.ActivityModel_setMultiplier(swigCPtr, this, multiplier);
  }
  public int multiply(int a) {
    return SwigAndroidGuideJNI.ActivityModel_multiply__SWIG_0(swigCPtr, this, a);
  }
  public static int multiply(int a, int b) {
    return SwigAndroidGuideJNI.ActivityModel_multiply__SWIG_1(a, b);
  }
  public ActivityModel() {
    this(SwigAndroidGuideJNI.new_ActivityModel(), true);
  }
}

ActivityModel activityModel = new ActivityModel();
Log.d(TAG, "mathExample() ActivityModel.multiply(5, 42): " + ActivityModel.multiply(5, 42));
activityModel.setMultiplier(3);
Log.d(TAG, "mathExample() activityModel.multiply(5): " + activityModel.multiply(6));

java.lang.UnsatisfiedLinkError: No implementation found for long
com.goldberg.swigandroidguide.swiggenerated.SwigAndroidGuideJNI.new_ActivityModel()
(tried Java_com_goldberg_swigandroidguide_swiggenerated_SwigAndroidGuideJNI_new_1ActivityModel
and Java_com_goldberg_swigandroidguide_swiggenerated_SwigAndroidGuideJNI_new_1ActivityModel__)

# We placed siwg-generated C++ code into the different directory,
# than the other code. We have to include the directory where our "ActivityModel.h" is located.
# In my case it is the directory on "CMakeLists.txt" file, i.e. 'this' directory.
include_directories(./) # < Add this line
add_library(
        native-lib
        SHARED
        native-lib.cpp
        # Add lines below
        ActivityModel.cpp
        swig-generated/SwigAndroidGuide_wrap.cpp)

D/MainActivity: simpleExample() ActivityModel.multiply(5, 42): 210
D/MainActivity: simpleExample() ActivityModel.multiply(5): 18

class IAndroidActivity
{
public:
    // Required. Otherwise SWIG will issue warning.
    virtual ~IAndroidActivity() = default;
    virtual void showToast(std::string value) = 0;
};

class ActivityModel
{
public:
    void onCreate(IAndroidActivity* androidActivity);
    // ...

void ActivityModel::onCreate(IAndroidActivity* androidActivity)
{
    androidActivity->showToast("Toast from C++");
}

// Enabling directors:
// %module SwigAndroidGuide // Delete this line
%module(directors="1") SwigAndroidGuide // Add this line
%{
#include "ActivityModel.h"
#include "IAndroidActivity.h" // Add this line
%}
%include "ActivityModel.h"
%feature("director") IAndroidActivity; // Add this line
%include "IAndroidActivity.h" // Add this line

%module(directors="1") SwigAndroidGuide
%include <std_string.i> // < Add this line
%{
#include "ActivityModel.h"
// ...

public class MainActivity extends AppCompatActivity
{
    // ...
    private class AndroidActivity extends IAndroidActivity
    {
        @Override
        public void showToast(String text)
        {
            Log.d(TAG, "showToast() Will show toast with text: " + text);
            Toast.makeText(MainActivity.this, text, Toast.LENGTH_SHORT).show();
        }
    }

public class MainActivity extends AppCompatActivity
{
    private final ActivityModel activityModel = new ActivityModel();
    private final AndroidActivity androidActivity = new AndroidActivity();
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        activityModel.onCreate(androidActivity);
        // ...

class Message
{
public:
    virtual ~Message() = default;
    int getId() { return _id; }
    void setId(int id) { _id = id; }
    std::string getText() { return _text; }
    void setText(std::string text) { _text = text; }
private:
    int _id;
    std::string _text;
};

class IAndroidActivity
{
public:
    virtual ~IAndroidActivity() = default; // Required. Otherwise SWIG will issue warning.
    virtual void showToast(std::string text) = 0;
    // Add this line
    virtual void sendMessage(std::shared_ptr<Message> message) = 0;

void ActivityModel::onCreate(IAndroidActivity *androidActivity)
{
    // ...
    shared_ptr<Message> message = make_shared<Message>();
    message->setId(22);
    message->setText("Greetings!");
    androidActivity->sendMessage(message);
}

%{
#include "ActivityModel.h"
#include "Message.h" // << Add this line
#include "IAndroidActivity.h"
%}
%include "ActivityModel.h"
// Add these lines
%shared_ptr(SwigAndroidGuide::Message); // Tell SWIG to process shared_ptr of this type
%include "Message.h" // Process file
%feature("director") IAndroidActivity;
%include "IAndroidActivity.h"

public class MainActivity extends AppCompatActivity
{
    // ...
    private class AndroidActivity extends IAndroidActivity
    {
        // ...
        @Override
        public void sendMessage(Message message)
        {
            Log.d(TAG, String.format(Locale.US, "Message sent: '%d %s'",
                                     message.getId(), message.getText()));
        }

typedef unsigned char byte;

#include "Types.h"
class PhotoMessage : public Message
{
public:
    std::vector<byte> getPhotoData() { return _photoData; }
    void setPhotoData(std::vector<byte> photoData) { _photoData = photoData; }
private:
    std::vector<byte> _photoData;
};

class IAndroidActivity
{
public:
    virtual ~IAndroidActivity() = default;
    virtual void showToast(std::string text) = 0;
    virtual void sendMessage(std::shared_ptr<Message> message) = 0;
    // Add this line
    virtual void sendPhotoMessage(std::shared_ptr<PhotoMessage> message) = 0;

void sendPhotoMessage(IAndroidActivity *androidActivity)
{
    shared_ptr<PhotoMessage> photoMessage = make_shared<PhotoMessage>();
    photoMessage->setId(27);
    photoMessage->setText("PhotoMessage!");
    vector<byte> photoData;
    photoData.push_back((byte)78);
    photoData.push_back((byte)64);
    photoData.push_back((byte)35);
    photoMessage->setPhotoData(photoData);
    androidActivity->sendPhotoMessage(photoMessage);
}
void ActivityModel::onCreate(IAndroidActivity *androidActivity)
{
    // ...
    sendPhotoMessage(androidActivity);
}

%module(directors="1") SwigAndroidGuide
// Process our Types.h first, so SWIG will be able to understand our types.
%include "Types.h" // << Add this line
%include <std_shared_ptr.i>
%include <std_string.i>
%include <std_vector.i>
%template(VectorByte) std::vector<byte>; // << Add this line
%{
#include "Types.h"
#include "Message.h"
#include "PhotoMessage.h" // << Add this line
#include "ActivityModel.h"
#include "IAndroidActivity.h"
%}
%shared_ptr(SwigAndroidGuide::Message);
%include "Message.h"
// Add these lines >>
%shared_ptr(SwigAndroidGuide::PhotoMessage);
%include "PhotoMessage.h"
%include "ActivityModel.h"
%feature("director") IAndroidActivity;
%include "IAndroidActivity.h"

public class VectorByte extends java.util.AbstractList<short> implements java.util.RandomAccess {
// ...
  public VectorByte(short[] initialElements) {
  //...
  }
  public VectorByte(Iterable<short> initialElements) {
  //...
  }
  public Short get(int index) {
    return doGet(index);
  }
  public Short set(int index, Short e) {
    return doSet(index, e);
  }
  public boolean add(Short e) {
    modCount++;
    doAdd(e);
    return true;
  }
  public void add(int index, Short e) {
    modCount++;
    doAdd(index, e);
  }
  public Short remove(int index) {
    modCount++;
    return doRemove(index);
  }
  public int size() {
    return doSize();
  }
  public long capacity() {
    return SwigAndroidGuideJNI.VectorByte_capacity(swigCPtr, this);
  }
  public void reserve(long n) {
    SwigAndroidGuideJNI.VectorByte_reserve(swigCPtr, this, n);
  }
  public void clear() {
    SwigAndroidGuideJNI.VectorByte_clear(swigCPtr, this);
  }
// ...
}

public class MainActivity extends AppCompatActivity
{
    // ...
    private class AndroidActivity extends IAndroidActivity
    {
        // ...
        @Override
        public void sendPhotoMessage(PhotoMessage message)
        {
            VectorByte data = message.getPhotoData();
            String dataString = "";
            for (int i = 0; i < data.size(); ++i)
            {
                dataString += data.get(i).toString() + " ";
            }
            Log.d(TAG, String.format(Locale.US,
                    "Photo message sent: '%d %s' with bytes: '%s'",
                    message.getId(), message.getText(), dataString));
        }

class IAndroidActivity
{
public: // ...
    virtual void sendMessage(std::shared_ptr<Message> message) = 0;
    virtual void sendPhotoMessage(std::shared_ptr<PhotoMessage> message) = 0;

void sendPhotoMessage(IAndroidActivity *androidActivity)
{
    shared_ptr<PhotoMessage> photoMessage = make_shared<PhotoMessage>();
    // ... initializing photoMessage ...
    // Pass child object to the function expecting the base type
    // sendMessage(shared_ptr<message>)
    androidActivity->sendMessage(photoMessage);
}

@Override
public void sendMessage(Message message)
{
    if (message instanceof PhotoMessage)
    {
        // Always false
    }
    // Always will throw ClassCastException
    PhotoMessage photoMessage = (PhotoMessage) message;
}

%extend SwigAndroidGuide::PhotoMessage {
    static std::shared_ptr<SwigAndroidGuide::PhotoMessage> dynamic_cast(std::shared_ptr<SwigAndroidGuide::Message> message) {
        return std::dynamic_pointer_cast<SwigAndroidGuide::PhotoMessage>(message);
    }
};

public class PhotoMessage extends Message {
  // ...
  public static PhotoMessage dynamic_cast(Message message) {
    long cPtr = SwigAndroidGuideJNI.PhotoMessage_dynamic_cast(Message.getCPtr(message), message);
    return (cPtr == 0) ? null : new PhotoMessage(cPtr, true);
  }

// This function is generated as we specified in %extend
SWIGINTERN std::shared_ptr< SwigAndroidGuide::PhotoMessage > SwigAndroidGuide_PhotoMessage_dynamic_cast(std::shared_ptr< SwigAndroidGuide::Message > arg){
        return std::dynamic_pointer_cast<swigandroidguide::photomessage>(arg);
    }
// ...
// SWIG connects our new function to Java
SWIGEXPORT jlong JNICALL Java_com_goldberg_swigandroidguide_swiggenerated_SwigAndroidGuideJNI_PhotoMessage_1dynamic_1cast(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::shared_ptr< SwigAndroidGuide::Message > arg1 ;
  std::shared_ptr< SwigAndroidGuide::Message > *argp1 ;
  std::shared_ptr< SwigAndroidGuide::PhotoMessage > result;
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(std::shared_ptr< SwigAndroidGuide::Message > **)&jarg1;
  if (argp1) arg1 = *argp1;
  // SWIG connects our new function to Java in this line
  result = SwigAndroidGuide_PhotoMessage_dynamic_cast(arg1);
  *(std::shared_ptr< SwigAndroidGuide::PhotoMessage > **)&jresult = result ? new std::shared_ptr< SwigAndroidGuide::PhotoMessage >(result) : 0;
  return jresult;
}

public class MainActivity extends AppCompatActivity
{
    // ...
    private class AndroidActivity extends IAndroidActivity
    {
        // ...
        @Override
        public void sendMessage(Message message)
        {
            PhotoMessage photoMessage = PhotoMessage.dynamic_cast(message);
            if (photoMessage != null)
            {
                Log.d(TAG, String.format(Locale.US, "Photo message sent: '%d %s, %d bytes'",
                        photoMessage.getId(), photoMessage.getText(), photoMessage.getPhotoData().size()));
                return;
            }
            Log.d(TAG, String.format(Locale.US, "Message sent: '%d %s'", message.getId(), message.getText()));
        }

void sendPhotoMessage(IAndroidActivity *androidActivity)
{
    // ...
    // androidActivity->sendPhotoMessage(photoMessage); // Delete this line
    androidActivity->sendMessage(photoMessage); // Add this line
}

D/MainActivity: Message sent: '22 Greetings!'
D/MainActivity: Photo message sent: '27 PhotoMessage!' with bytes: '78 64 35 '

%define %dynamic_cast_extension(CppNamespace, DescendantClass, BaseClass)
%extend CppNamespace::DescendantClass
{
    static std::shared_ptr<CppNamespace::DescendantClass>
    dynamic_cast(std::shared_ptr<CppNamespace::BaseClass> arg)
    {
        return std::dynamic_pointer_cast<CppNamespace::DescendantClass>(arg);
    }
};
%enddef

// ...
%include <std_string.i>
%include <std_vector.i>
%include "dynamic_cast_extension.i" // Add this line
// ...
// Remove this chunk
/*
%extend SwigAndroidGuide::PhotoMessage {
    static std::shared_ptr<swigandroidguide::photomessage> dynamic_cast(std::shared_ptr<swigandroidguide::message> message) {
        return std::dynamic_pointer_cast<swigandroidguide::photomessage>(message);
    }
};
*/
%dynamic_cast_extension(SwigAndroidGuide, PhotoMessage, Message) // Add this line