capacitor-plugin-recorder 0.0.1

package/android/src/main/java/com/capacitor/recorderplayer/RecorderPlayer.java

@@ -0,0 +1,524 @@
+package com.capacitor.recorderplayer;
+
+import android.content.Context;
+import android.media.AudioAttributes;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class RecorderPlayer {
+
+    private static final String TAG = "RecorderPlayer";
+
+    public enum RecordingStatus {
+        RECORDING("recording"),
+        PAUSED("paused"),
+        STOPPED("stopped");
+
+        private final String value;
+
+        RecordingStatus(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    public enum PlaybackStatus {
+        PLAYING("playing"),
+        PAUSED("paused"),
+        STOPPED("stopped"),
+        ENDED("ended");
+
+        private final String value;
+
+        PlaybackStatus(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    public interface RecorderPlayerListener {
+        void onRecordingStatusChange(RecordingStatus status, int duration);
+        void onPlaybackStatusChange(String playerId, PlaybackStatus status, int currentPosition, int duration);
+    }
+
+    // Inner class to hold player state
+    private static class PlayerState {
+        final String playerId;
+        final MediaPlayer mediaPlayer;
+        PlaybackStatus status = PlaybackStatus.STOPPED;
+        Handler playbackHandler;
+        Runnable playbackRunnable;
+
+        PlayerState(String playerId, MediaPlayer mediaPlayer) {
+            this.playerId = playerId;
+            this.mediaPlayer = mediaPlayer;
+            this.playbackHandler = new Handler(Looper.getMainLooper());
+        }
+
+        void startTimer(RecorderPlayerListener listener) {
+            stopTimer();
+            playbackRunnable = new Runnable() {
+                @Override
+                public void run() {
+                    if (status == PlaybackStatus.PLAYING && mediaPlayer != null) {
+                        notifyStatusChange(listener);
+                        playbackHandler.postDelayed(this, 250);
+                    }
+                }
+            };
+            playbackHandler.postDelayed(playbackRunnable, 250);
+        }
+
+        void stopTimer() {
+            if (playbackRunnable != null) {
+                playbackHandler.removeCallbacks(playbackRunnable);
+                playbackRunnable = null;
+            }
+        }
+
+        void notifyStatusChange(RecorderPlayerListener listener) {
+            if (listener != null && mediaPlayer != null) {
+                try {
+                    int currentPosition = mediaPlayer.getCurrentPosition();
+                    int duration = mediaPlayer.getDuration();
+                    listener.onPlaybackStatusChange(playerId, status, currentPosition, duration);
+                } catch (IllegalStateException e) {
+                    // MediaPlayer may be in invalid state
+                }
+            }
+        }
+
+        void release() {
+            stopTimer();
+            if (mediaPlayer != null) {
+                try {
+                    mediaPlayer.stop();
+                } catch (IllegalStateException ignored) {
+                }
+                mediaPlayer.release();
+            }
+        }
+    }
+
+    private final Context context;
+    private final AudioManager audioManager;
+    private MediaRecorder mediaRecorder;
+
+    private RecordingStatus recordingStatus = RecordingStatus.STOPPED;
+
+    private String currentRecordingPath;
+    private long recordingStartTime;
+    private long pausedDuration;
+
+    // Multiple players support
+    private final Map<String, PlayerState> players = new HashMap<>();
+    private final AtomicInteger playerIdCounter = new AtomicInteger(0);
+
+    private RecorderPlayerListener listener;
+
+    public RecorderPlayer(Context context) {
+        this.context = context;
+        this.audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+    }
+
+    public void setListener(RecorderPlayerListener listener) {
+        this.listener = listener;
+    }
+
+    private String generatePlayerId() {
+        return "player-" + playerIdCounter.incrementAndGet() + "-" + System.currentTimeMillis();
+    }
+
+    public void startRecord(String path) throws Exception {
+        if (recordingStatus != RecordingStatus.STOPPED) {
+            throw new Exception("Recording already in progress");
+        }
+
+        // Use files directory (matches Capacitor's Directory.Data)
+        File dataDir = context.getFilesDir();
+
+        File audioFile;
+        if (path != null) {
+            // Use relative path within data directory
+            audioFile = new File(dataDir, path);
+            // Create parent directories if needed
+            File parentDir = audioFile.getParentFile();
+            if (parentDir != null && !parentDir.exists()) {
+                parentDir.mkdirs();
+            }
+        } else {
+            String audioFilename = "recording_" + System.currentTimeMillis() + ".m4a";
+            audioFile = new File(dataDir, audioFilename);
+        }
+        currentRecordingPath = audioFile.getAbsolutePath();
+
+        Log.d(TAG, "Starting recording to: " + currentRecordingPath);
+
+        try {
+            mediaRecorder = new MediaRecorder();
+            mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
+            mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
+            mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
+            mediaRecorder.setAudioSamplingRate(44100);
+            mediaRecorder.setAudioEncodingBitRate(128000);
+            mediaRecorder.setOutputFile(currentRecordingPath);
+            mediaRecorder.prepare();
+            mediaRecorder.start();
+
+            recordingStartTime = System.currentTimeMillis();
+            pausedDuration = 0;
+            recordingStatus = RecordingStatus.RECORDING;
+            notifyRecordingStatusChange();
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to start recording: " + e.getMessage());
+            throw new Exception("Failed to start recording: " + e.getMessage());
+        }
+    }
+
+    public RecordResult stopRecord() throws Exception {
+        if (mediaRecorder == null || recordingStatus == RecordingStatus.STOPPED) {
+            throw new Exception("No recording in progress");
+        }
+
+        int duration = (int) (System.currentTimeMillis() - recordingStartTime - pausedDuration);
+
+        try {
+            mediaRecorder.stop();
+            mediaRecorder.release();
+        } catch (RuntimeException e) {
+            Log.e(TAG, "Error stopping recording: " + e.getMessage());
+        }
+
+        mediaRecorder = null;
+        String path = currentRecordingPath;
+        recordingStatus = RecordingStatus.STOPPED;
+        notifyRecordingStatusChange();
+
+        // Verify file exists and has content
+        File recordedFile = new File(path);
+        Log.d(TAG, "Recording stopped. File exists: " + recordedFile.exists() + ", size: " + recordedFile.length());
+
+        return new RecordResult(path, duration);
+    }
+
+    public void pauseRecord() throws Exception {
+        if (mediaRecorder == null || recordingStatus != RecordingStatus.RECORDING) {
+            throw new Exception("No active recording to pause");
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            mediaRecorder.pause();
+            pausedDuration = System.currentTimeMillis() - recordingStartTime;
+            recordingStatus = RecordingStatus.PAUSED;
+            notifyRecordingStatusChange();
+        } else {
+            throw new Exception("Pause recording is not supported on this Android version");
+        }
+    }
+
+    public void resumeRecord() throws Exception {
+        if (mediaRecorder == null || recordingStatus != RecordingStatus.PAUSED) {
+            throw new Exception("No paused recording to resume");
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            mediaRecorder.resume();
+            recordingStartTime = System.currentTimeMillis() - pausedDuration;
+            recordingStatus = RecordingStatus.RECORDING;
+            notifyRecordingStatusChange();
+        } else {
+            throw new Exception("Resume recording is not supported on this Android version");
+        }
+    }
+
+    public PreparePlayResult preparePlay(String path) throws Exception {
+        Log.d(TAG, "preparePlay called with path: " + path);
+
+        // Use files directory (matches Capacitor's Directory.Data)
+        File dataDir = context.getFilesDir();
+        File audioFile = new File(dataDir, path);
+        String absolutePath = audioFile.getAbsolutePath();
+
+        if (!audioFile.exists()) {
+            Log.e(TAG, "Audio file not found at path: " + path);
+            throw new Exception("Audio file not found at path: " + path);
+        }
+
+        Log.d(TAG, "Audio file exists, size: " + audioFile.length());
+
+        try {
+            MediaPlayer mediaPlayer = new MediaPlayer();
+
+            // Set audio attributes for music/media playback through speaker
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                AudioAttributes audioAttributes = new AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_MEDIA)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                        .build();
+                mediaPlayer.setAudioAttributes(audioAttributes);
+            } else {
+                mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
+            }
+
+            mediaPlayer.setDataSource(absolutePath);
+
+            String playerId = generatePlayerId();
+            PlayerState playerState = new PlayerState(playerId, mediaPlayer);
+            players.put(playerId, playerState);
+
+            mediaPlayer.setOnPreparedListener(mp -> {
+                Log.d(TAG, "MediaPlayer prepared, duration: " + mp.getDuration());
+            });
+
+            mediaPlayer.setOnCompletionListener(mp -> {
+                Log.d(TAG, "Playback completed for player: " + playerId);
+                PlayerState ps = players.get(playerId);
+                if (ps != null) {
+                    ps.status = PlaybackStatus.ENDED;
+                    ps.stopTimer();
+                    ps.notifyStatusChange(listener);
+                }
+            });
+
+            mediaPlayer.setOnErrorListener((mp, what, extra) -> {
+                Log.e(TAG, "MediaPlayer error: what=" + what + ", extra=" + extra);
+                PlayerState ps = players.get(playerId);
+                if (ps != null) {
+                    ps.status = PlaybackStatus.STOPPED;
+                    ps.stopTimer();
+                    ps.notifyStatusChange(listener);
+                }
+                return true;
+            });
+
+            mediaPlayer.prepare();
+
+            int duration = mediaPlayer.getDuration();
+            Log.d(TAG, "Audio prepared successfully, duration: " + duration + "ms, playerId: " + playerId);
+
+            playerState.notifyStatusChange(listener);
+            return new PreparePlayResult(playerId, duration);
+        } catch (IOException e) {
+            Log.e(TAG, "Failed to load audio: " + e.getMessage());
+            throw new Exception("Failed to load audio: " + e.getMessage());
+        }
+    }
+
+    public void play(String playerId) throws Exception {
+        Log.d(TAG, "play called for playerId: " + playerId);
+
+        PlayerState playerState = players.get(playerId);
+        if (playerState == null) {
+            throw new Exception("No player found with ID: " + playerId);
+        }
+
+        playerState.mediaPlayer.start();
+        playerState.status = PlaybackStatus.PLAYING;
+        playerState.startTimer(listener);
+        playerState.notifyStatusChange(listener);
+
+        Log.d(TAG, "Playback started, isPlaying: " + playerState.mediaPlayer.isPlaying());
+    }
+
+    public void pausePlay(String playerId) throws Exception {
+        PlayerState playerState = players.get(playerId);
+        if (playerState == null) {
+            throw new Exception("No player found with ID: " + playerId);
+        }
+
+        if (playerState.status != PlaybackStatus.PLAYING) {
+            throw new Exception("No audio playing to pause");
+        }
+
+        playerState.mediaPlayer.pause();
+        playerState.status = PlaybackStatus.PAUSED;
+        playerState.stopTimer();
+        playerState.notifyStatusChange(listener);
+    }
+
+    public void resumePlay(String playerId) throws Exception {
+        PlayerState playerState = players.get(playerId);
+        if (playerState == null) {
+            throw new Exception("No player found with ID: " + playerId);
+        }
+
+        if (playerState.status != PlaybackStatus.PAUSED) {
+            throw new Exception("No paused audio to resume");
+        }
+
+        playerState.mediaPlayer.start();
+        playerState.status = PlaybackStatus.PLAYING;
+        playerState.startTimer(listener);
+        playerState.notifyStatusChange(listener);
+    }
+
+    public void stopPlay(String playerId) throws Exception {
+        PlayerState playerState = players.get(playerId);
+        if (playerState == null) {
+            throw new Exception("No player found with ID: " + playerId);
+        }
+
+        playerState.mediaPlayer.stop();
+        playerState.mediaPlayer.seekTo(0);
+        try {
+            playerState.mediaPlayer.prepare();
+        } catch (IOException ignored) {
+        }
+        playerState.status = PlaybackStatus.STOPPED;
+        playerState.stopTimer();
+        playerState.notifyStatusChange(listener);
+    }
+
+    public void seekTo(String playerId, int position) throws Exception {
+        PlayerState playerState = players.get(playerId);
+        if (playerState == null) {
+            throw new Exception("No player found with ID: " + playerId);
+        }
+
+        int duration = playerState.mediaPlayer.getDuration();
+        if (position < 0 || position > duration) {
+            throw new Exception("Invalid seek position");
+        }
+
+        playerState.mediaPlayer.seekTo(position);
+        playerState.notifyStatusChange(listener);
+    }
+
+    public PlaybackStatusResult getPlaybackStatus(String playerId) {
+        PlayerState playerState = players.get(playerId);
+        if (playerState == null) {
+            return null;
+        }
+
+        int currentPosition = playerState.mediaPlayer.getCurrentPosition();
+        int duration = playerState.mediaPlayer.getDuration();
+        return new PlaybackStatusResult(playerId, playerState.status.getValue(), currentPosition, duration);
+    }
+
+    public RecordingStatusResult getRecordingStatus() {
+        int duration = 0;
+        if (recordingStatus == RecordingStatus.RECORDING) {
+            duration = (int) (System.currentTimeMillis() - recordingStartTime);
+        } else if (recordingStatus == RecordingStatus.PAUSED) {
+            duration = (int) pausedDuration;
+        }
+        return new RecordingStatusResult(recordingStatus.getValue(), duration);
+    }
+
+    public void destroyPlayer(String playerId) {
+        PlayerState playerState = players.remove(playerId);
+        if (playerState != null) {
+            playerState.release();
+            Log.d(TAG, "Destroyed player: " + playerId);
+        }
+    }
+
+    private void notifyRecordingStatusChange() {
+        if (listener != null) {
+            RecordingStatusResult status = getRecordingStatus();
+            listener.onRecordingStatusChange(recordingStatus, status.getDuration());
+        }
+    }
+
+    // Result classes
+    public static class RecordResult {
+        private final String path;
+        private final int duration;
+
+        public RecordResult(String path, int duration) {
+            this.path = path;
+            this.duration = duration;
+        }
+
+        public String getPath() {
+            return path;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+    }
+
+    public static class PreparePlayResult {
+        private final String playerId;
+        private final int duration;
+
+        public PreparePlayResult(String playerId, int duration) {
+            this.playerId = playerId;
+            this.duration = duration;
+        }
+
+        public String getPlayerId() {
+            return playerId;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+    }
+
+    public static class PlaybackStatusResult {
+        private final String playerId;
+        private final String status;
+        private final int currentPosition;
+        private final int duration;
+
+        public PlaybackStatusResult(String playerId, String status, int currentPosition, int duration) {
+            this.playerId = playerId;
+            this.status = status;
+            this.currentPosition = currentPosition;
+            this.duration = duration;
+        }
+
+        public String getPlayerId() {
+            return playerId;
+        }
+
+        public String getStatus() {
+            return status;
+        }
+
+        public int getCurrentPosition() {
+            return currentPosition;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+    }
+
+    public static class RecordingStatusResult {
+        private final String status;
+        private final int duration;
+
+        public RecordingStatusResult(String status, int duration) {
+            this.status = status;
+            this.duration = duration;
+        }
+
+        public String getStatus() {
+            return status;
+        }
+
+        public int getDuration() {
+            return duration;
+        }
+    }
+}