Java Android应用程序出错，JNI在应用程序中检测到错误。需要构造函数，但无效

我负责修改几年前由第三方公司创建的现有android应用程序。正如您所料，我在编译和运行源代码方面遇到了问题。最终目标是为不同的地区开发新版本的应用程序

虽然我得到了这份工作，但我的编码专业知识是Python、Matlab等，而不是Java，我正在努力解决这些问题，因为这超出了我的专业知识（后端、数据处理等）

我可以让应用程序在模拟器上编译和运行，之前的文章对我很有帮助，但是当我提出一个涉及c代码的请求时，应用程序会崩溃

该应用程序是一个潮汐应用程序，使用C代码计算潮汐高程和潮流。它使用NDK和JNI来实现这一点，当前的错误消息非常长，所以我将尝试并发布希望相关的位

07-26 09:20:09.307 3730-3730/com.noc.anytide A/art: art/runtime/java_vm_ext.cc:470] JNI DETECTED ERROR IN APPLICATION: expected a constructor but void com.noc.anytide.POLPredict$POLPredictResult.populateResult(double[], float, long, long): 0x86aac464
    art/runtime/java_vm_ext.cc:470]     in call to NewObjectV
    art/runtime/java_vm_ext.cc:470]     from com.noc.anytide.POLPredict$POLPredictResult com.noc.anytide.POLPredict.POLPredictShim(double, int, long[], long[], long[], double, int, int, int, float, long, int)
    art/runtime/java_vm_ext.cc:470] "main" prio=5 tid=1 Runnable
    art/runtime/java_vm_ext.cc:470]   | group="main" sCount=0 dsCount=0 obj=0x7488b000 self=0xa990b400
    art/runtime/java_vm_ext.cc:470]   | sysTid=3730 nice=1 cgrp=default sched=0/0 handle=0xadc5d534 

与此相关的java文件如下所示：

package com.noc.anytide;

import android.annotation.SuppressLint;
import android.util.Log;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;

public class POLPredict {

    public static double duration = (10f * 24f);
    public static int nvals = 400;
    public static long offset;
    public static float maxY;
    public static double currentHeight, prevHeight, nextHeight;
    public static boolean rising;
    public static boolean dataClippedLeft = false;
    public static boolean dataClippedRight = false;

    private native POLPredictResult POLPredictShim(double duration, int nvals, long Hi[], long Gi[], long Ki[], double ref_height, int Base_dd, int Base_mm, int Base_yy,
            float startTime, long startDateTime, int constit_count);

    static {
        System.loadLibrary("POLPredict");
    }

    @SuppressLint("SimpleDateFormat")
    public static String unixToString(long timestamp) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM HH:mm");
        Date date = new Date(timestamp);
        dateFormat.setTimeZone(TimeZone.getTimeZone("Europe/London"));
        return dateFormat.format(date);
    }

    public class POLPredictResult {
        public List<Number> result;
        public List<Number> dates;
        public int numVals;

        public void populateResult(double resultArray[], float maxRange, long startDateTime, long interval) {
            result = new ArrayList<Number>();
            dates = new ArrayList<Number>();
            long currentTime = System.currentTimeMillis();
            long prevTime = currentTime - 1800000;
            long nextTime = currentTime + 1800000;
            boolean containsCurrentTide = false;
            maxY = 0.0f;
            numVals = resultArray.length;
            boolean valid = false;
            boolean partiallyValid = false;
            long pStart = 0;
            long pEnd = 0;

            long endDataTime = (startDateTime + (interval * numVals));

            if(startDateTime <= currentTime && endDataTime >= currentTime) {
                containsCurrentTide = true;
            } else {
                currentHeight = -1.0;
            }

            dataClippedLeft = false;
            dataClippedRight = false;

            if(BookMarksHandler.isNL) {
                valid = true;
            } else {
                for(int i=0;i<InAppPurchasing.tidalPurchases.size();i++) {
                    long s = InAppPurchasing.tidalPurchases.get(i).start;
                    long e = InAppPurchasing.tidalPurchases.get(i).end;
                    if(InAppPurchasing.tidalPurchases.get(i).purchased ) {
                        if(startDateTime > s && endDataTime < e) {
                            valid = true;
                            break;
                        }
                        if((startDateTime > s && startDateTime < e) || (endDataTime > s && endDataTime < e)){
                            partiallyValid = true;
                            pStart = s;
                            pEnd = e;
                            break;
                        }
                    }
                }
            }
            boolean wroteLevel = false;
            for (int i = 0; i < numVals; i++) {
                if(!valid && !partiallyValid && ((currentTime - (12*3600000) > startDateTime) || (currentTime + (12*3600000) < startDateTime))) {
                    if(wroteLevel) {
                        dataClippedRight = true; 
                    } else {
                        dataClippedLeft = true;
                    }
                    this.result.add(-10.0);
                } else if(partiallyValid) {
                    if(startDateTime > pStart && startDateTime < pEnd) {
                        this.result.add((Number) resultArray[i]);
                        wroteLevel = true;
                    } else {
                        if(wroteLevel) {
                            dataClippedRight = true; 
                        } else {
                            dataClippedLeft = true;
                        }
                        this.result.add(-10.0);
                    }
                } else {
                    this.result.add((Number) resultArray[i]);
                    wroteLevel = true;
                }
                if(containsCurrentTide && startDateTime < currentTime) {
                    currentHeight = (double) Math.round(resultArray[i] * 100) / 100;
                }
                if(containsCurrentTide && startDateTime < prevTime) {
                    prevHeight = (double) Math.round(resultArray[i] * 100) / 100;
                }
                if(containsCurrentTide && startDateTime < nextTime) {
                    nextHeight = (double) Math.round(resultArray[i] * 100) / 100;
                }
                this.dates.add(startDateTime);
                startDateTime += interval;
            }

            maxY = maxRange;

            if(nextHeight > prevHeight) rising=true;
            else rising = false;
        }

        public void populateCurrentResult(double resultArray[], float maxRange, long startDateTime, long interval) {

            result = new ArrayList<Number>();
            dates = new ArrayList<Number>();
            for (int i = 0; i <  resultArray.length; i++) {
                this.result.add((Number) resultArray[i]);
                this.dates.add(startDateTime);
                startDateTime += interval;
            }
        }
    }

    public POLPredictResult POLPredictGo(double duration, int nvals, long Hi[], long Gi[], long Ki[], double ref_height, int Base_dd, int Base_mm, int Base_yy, float startTime, long unixStartTime, int constit_count) {

        return POLPredictShim(duration, nvals, Hi, Gi, Ki, ref_height, Base_dd, Base_mm, Base_yy, startTime, unixStartTime, constit_count);
    }
}

package com.noc.anytide；
导入android.annotation.SuppressLint；
导入android.util.Log；
导入java.text.simpleDataFormat；
导入java.util.ArrayList；
导入java.util.Date；
导入java.util.List；
导入java.util.TimeZone；
公共课{
公共静态双持续时间=（10f*24f）；
公共静态int nvals=400；
公共静态长偏移量；
公共静态浮点最大值；
公共静态双电流高度、前一高度、后一高度；
公众参与；
公共静态布尔值dataClippedLeft=false；
公共静态布尔dataClippedRight=false；
私有本机POLDecdictResult POLDecdictShim（双持续时间，整数nvals，长Hi[]，长Gi[]，长Ki[]，双参考高度，整数基日，整数基日，整数基日，整数基日，
浮动起始时间、长起始时间、整数组成计数）；
静止的{
系统加载库（“POLPredict”）；
}
@SuppressLint（“SimpleDataFormat”）
公共静态字符串unixToString（长时间戳）{
SimpleDateFormat dateFormat=新的SimpleDateFormat（“dd/MM HH:MM”）；
日期=新日期（时间戳）；
dateFormat.setTimeZone（TimeZone.getTimeZone（“欧洲/伦敦”）；
返回日期格式。格式（日期）；
}
公共类结果{
公开名单结果；
公开名单日期；
公共国际货币基金组织；
public void populateResult（双结果数组[]，浮点最大范围，长起始日期时间，长间隔）{
结果=新的ArrayList（）；
日期=新的ArrayList（）；
长currentTime=System.currentTimeMillis（）；
long prevTime=当前时间-1800000；
长下一个时间=当前时间+1800000；
布尔containsCurrentTide=false；
最大值=0.0f；
numVals=resultArray.length；
布尔有效=假；
布尔值partiallyValid=false；
长pStart=0；
长挂起=0；
long-endDataTime=（startDateTime+（间隔*numVals））；
如果（startDateTime=currentTime）{
ContainesCurrentTide=真；
}否则{
currentHeight=-1.0；
}
dataClippedLeft=false；
dataClippedRight=false；
if（BookMarksHandler.isNL）{
有效=真；
}否则{
对于（int i=0；i s&&endDataTimes&&startDateTimes&&endDataTimestartDateTime）| |（currentTime+（12*3600000）pStart&&startDateTimeprevHeight）上升=真；
否则上升=错误；
}
public void populateCurrentResult（双结果数组[]，浮点最大范围，长起始日期时间，长间隔）{
结果=新的ArrayList（）；
日期=新的ArrayList（）；
对于（int i=0；i