code: /*
      Copyright 2022 Picovoice Inc.
  
      You may not use this file except in compliance with the license. A copy of the license is
      located in the "LICENSE" file accompanying this source.
  
      Unless required by applicable law or agreed to in writing, software distributed under the
      License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
      express or implied. See the License for the specific language governing permissions and
      limitations under the License.
  */
  
  package ai.picovoice.porcupine.demo;
  
  import android.content.Context;
  import android.content.res.AssetManager;
  
  import androidx.annotation.NonNull;
  import androidx.test.platform.app.InstrumentationRegistry;
  
  import com.microsoft.appcenter.espresso.Factory;
  import com.microsoft.appcenter.espresso.ReportHelper;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Rule;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.util.ArrayList;
  
  import ai.picovoice.porcupine.Porcupine;
  
  public class BaseTest {
  
      @Rule
      public ReportHelper reportHelper = Factory.getReportHelper();
  
      Context testContext;
      Context appContext;
      AssetManager assetManager;
      String testResourcesPath;
      String accessKey;
  
      @After
      public void TearDown() {
          reportHelper.label("Stopping App");
      }
  
      @Before
      public void Setup() throws IOException {
          testContext = InstrumentationRegistry.getInstrumentation().getContext();
          appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
          assetManager = testContext.getAssets();
          extractAssetsRecursively("test_resources");
          testResourcesPath = new File(appContext.getFilesDir(), "test_resources").getAbsolutePath();
  
          accessKey = appContext.getString(R.string.pvTestingAccessKey);
      }
  
      public static String getTestDataString() throws IOException {
          Context testContext = InstrumentationRegistry.getInstrumentation().getContext();
          AssetManager assetManager = testContext.getAssets();
  
          InputStream is = new BufferedInputStream(assetManager.open("test_resources/test_data.json"), 256);
          ByteArrayOutputStream result = new ByteArrayOutputStream();
  
          byte[] buffer = new byte[256];
          int bytesRead;
          while ((bytesRead = is.read(buffer)) != -1) {
              result.write(buffer, 0, bytesRead);
          }
  
          return result.toString("UTF-8");
      }
  
      private void extractAssetsRecursively(String path) throws IOException {
  
          String[] list = assetManager.list(path);
          if (list.length > 0) {
              File outputFile = new File(appContext.getFilesDir(), path);
              if (!outputFile.exists()) {
                  outputFile.mkdirs();
              }
  
              for (String file : list) {
                  String filepath = path + "/" + file;
                  extractAssetsRecursively(filepath);
              }
          } else {
              extractTestFile(path);
          }
      }
  
      private void extractTestFile(String filepath) throws IOException {
  
          InputStream is = new BufferedInputStream(assetManager.open(filepath), 256);
          File absPath = new File(appContext.getFilesDir(), filepath);
          OutputStream os = new BufferedOutputStream(new FileOutputStream(absPath), 256);
          int r;
          while ((r = is.read()) != -1) {
              os.write(r);
          }
          os.flush();
  
          is.close();
          os.close();
      }
  
      ArrayList<Integer> processTestAudio(@NonNull Porcupine p, File testAudio) throws Exception {
          FileInputStream audioInputStream = new FileInputStream(testAudio);
  
          byte[] rawData = new byte[p.getFrameLength() * 2];
          short[] pcm = new short[p.getFrameLength()];
          ByteBuffer pcmBuff = ByteBuffer.wrap(rawData).order(ByteOrder.LITTLE_ENDIAN);
  
          audioInputStream.skip(44);
  
          ArrayList<Integer> detectionResults = new ArrayList<>();
          while (audioInputStream.available() > 0) {
              int numRead = audioInputStream.read(pcmBuff.array());
              if (numRead == p.getFrameLength() * 2) {
                  pcmBuff.asShortBuffer().get(pcm);
                  int keywordIndex = p.process(pcm);
                  if (keywordIndex >= 0) {
                      detectionResults.add(keywordIndex);
                  }
              }
          }
          return detectionResults;
      }
  }
  