[Android速通]联网通信和多媒体

TaterLi

4 天前

到这里终于开始主要接触别人的轮子,其实到这里已经有能力做一些简单App,不过一些常用的轮子还是要抽出来学一下,当然里面也会贯穿一些常用知识点.

下一步,看一下如何让App联网通信,在学习网络应用之前,要先明确一点,只有UI线程可以刷屏,同时,网络很耗时,所以不能放在UI线程,所以这就有前后分离,比如下面这个例子.

private class PlayThread extends Thread {
    @Override
    public void run(){
        while(true){
            Calendar calendar = Calendar.getInstance();
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);

            String time = String.format("%02d:%02d:%02d", hour, minute, second);

            // mHandler.sendEmptyMessage(0);
            Message message = Message.obtain();
            message.what = SET_TXT;
            message.obj = time;
            mHandler.sendMessage(message);
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 创建处理器对象mHandler
private Handler mHandler = new Handler(Looper.getMainLooper()){
    public void handleMessage(Message message){
        // 收到Msg
        if (message.what == SET_TXT){
            tv_hello.setText(message.obj.toString());
        }
    }
};

当然因为他很简单,他也可以用runOnUiThread直接在内部往外调用.

private class PlayThread extends Thread {
    @Override
    public void run(){
        while(true){
            Calendar calendar = Calendar.getInstance();
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);

            String time = String.format("%02d:%02d:%02d", hour, minute, second);

            runOnUiThread(() -> {
                tv_hello.setText(time);
            });
         
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

除了这种方法,安卓还提供了WorkManager,需要修改build.gradle引入.

dependencies {

    implementation libs.appcompat
    implementation libs.material
    implementation libs.activity
    implementation libs.constraintlayout
    testImplementation libs.junit
    androidTestImplementation libs.ext.junit
    androidTestImplementation libs.espresso.core
    
    // WorkManager库各版本见 https://mvnrepository.com/artifact/androidx.work/work-runtime
    implementation 'androidx.work:work-runtime:2.10.0'
}

使用WordManager可以把复杂的任务独立成一个类里,并由系统安排他合适的时间执行,异步获得数据,当然,任务不是UI线程,他依然不可以刷新标签.

先创建一个包含生成随机数能力的Worker.

public class RandomNumberWorker extends Worker {
    public static final String KEY_MIN_VALUE = "min_value";
    public static final String KEY_MAX_VALUE = "max_value";
    public static final String KEY_RESULT = "random_result";

    public RandomNumberWorker(
            @NonNull Context context,
            @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    @NonNull
    @Override
    public Result doWork() {
        // 获取输入数据
        int min = getInputData().getInt(KEY_MIN_VALUE, 0);
        int max = getInputData().getInt(KEY_MAX_VALUE, 100);

        // 生成随机数
        Random random = new Random();
        int randomNumber = random.nextInt(max - min + 1) + min;

        // 创建输出数据
        Data outputData = new Data.Builder()
                .putInt(KEY_RESULT, randomNumber)
                .build();

        // 返回结果
        return Result.success(outputData);
    }
}

之后在其他线程(比如UI线程)安排这个任务,并在可用时获得他的返回.

// 创建输入数据
Data inputData = new Data.Builder()
        .putInt(RandomNumberWorker.KEY_MIN_VALUE, 10)
        .putInt(RandomNumberWorker.KEY_MAX_VALUE, 50)
        .build();

// 创建约束条件
Constraints constraints = new Constraints.Builder()
        .setRequiredNetworkType(NetworkType.CONNECTED)
        .setRequiresBatteryNotLow(true)
        .build();

// 创建一次性工作请求
OneTimeWorkRequest workRequest = new OneTimeWorkRequest.Builder(RandomNumberWorker.class)
        .setInputData(inputData)
        .setConstraints(constraints)
        .build();

// 观察工作状态
WorkManager.getInstance(this).getWorkInfoByIdLiveData(workRequest.getId())
        .observe(this, new Observer<WorkInfo>() {
            @Override
            public void onChanged(WorkInfo workInfo) {
                if (workInfo != null) {
                    if (workInfo.getState() == WorkInfo.State.SUCCEEDED) {
                        // 任务完成，获取输出数据
                        int result = workInfo.getOutputData().getInt(
                                RandomNumberWorker.KEY_RESULT, 0);
                        tvHello.setText("随机数: " + result);
                    } else if (workInfo.getState() == WorkInfo.State.FAILED) {
                        tvHello.setText("任务失败");
                    }
                }
            }
        });

// 启动作业
WorkManager.getInstance(this).enqueue(workRequest);
tvHello.setText("任务已启动...");

除了一次性任务外,也可以创建周期性任务.

// 创建周期性工作请求 (最小间隔15分钟)
PeriodicWorkRequest periodicWorkRequest = 
        new PeriodicWorkRequest.Builder(RandomNumberWorker.class, 
                15, TimeUnit.MINUTES)
                .setInputData(new Data.Builder()
                        .putInt(RandomNumberWorker.KEY_MIN_VALUE, 100)
                        .putInt(RandomNumberWorker.KEY_MAX_VALUE, 200)
                        .build())
                .build();

下面说网络通信,最常见就是调用各种API,大多数API返回都是JSON,所以也先引入一个JSON库.

// gson库各版本见 https://mvnrepository.com/artifact/com.google.code.gson/gson
implementation 'com.google.code.gson:gson:2.13.0'
// okhttp库各版本见 https://mvnrepository.com/artifact/com.squareup.okhttp3/okhttp
implementation 'com.squareup.okhttp3:okhttp:4.12.0'

为了上网,还得添加权限.

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

一般情况下,比如我写了一个简单的图片上传,并通过返回的来判断是否成功.

private boolean uploadImage(String imageUri, String serverFileName) {
    OkHttpClient client = new OkHttpClient();
    File file = new File(imageUri);
    Gson gson = new Gson();

    if (!file.exists()) {
        return false;
    }

    // 如果未指定服务器文件名，则使用原文件名
    String uploadFileName = (serverFileName == null || serverFileName.isEmpty())
            ? file.getName() : serverFileName;

    RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("filename",uploadFileName)
            .addFormDataPart("file", uploadFileName,
                    RequestBody.create(MediaType.parse("image/*"), file))
            .build();

    Request request = new Request.Builder()
            .url("https://note.242345.xyz/DCIM/index.php") // 替换为你的上传URL
            .post(requestBody)
            .build();

    try (Response response = client.newCall(request).execute()) {
        if (!response.isSuccessful()) {
            return false;
        }

        // 解析服务器返回的JSON
        String responseBody = response.body().string();
        ServerResponse serverResponse = gson.fromJson(responseBody, ServerResponse.class);

        // 根据服务器返回的success字段判断是否成功
        if (serverResponse != null && serverResponse.success){
            AppDatabase database = AppDatabase.getDatabase(getApplicationContext());
            ImageProcessor processor = new ImageProcessor(getApplicationContext());
            processor.processImage(imageUri, database.imageDao());
            return true;
        }else{
            return false;
        }
    } catch (IOException e) {
        Log.e(TAG, "上传图片失败", e);
        return false;
    }
}

我通过运用之前数据库的知识,简单拼了一个自动上传备份照片的功能,当然毕竟是一个学了几天的新手,代码肯定很烂.

https://github.com/nickfox-taterli/simple-android-leran

主题逻辑就是打开后会自动上传图片,每次上传后会刷新视图,显示剩余还没上传的图片,再次说了,是非常烂的代码.

除了这些HTTP请求外,还有Socket和WebSocket两种,因为HTTP是单向查询的,所以对于某些需要推送的就不太好用,因为安卓已经发展很多年了,太多轮子可以用了,但是服务器端的话也要采用一些兼容SocketIO库的选择才行,不然的话直接实现看了下还是挺复杂的.

除了联网通信外,App中还有很多常见的应用,比如播放,录制音频,播放,录制视频,拍照,显示图片.

启动系统自带录音机进行录音.

private void startSystemRecording() {
    // 检查权限
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) 
            != PackageManager.PERMISSION_GRANTED) {
        ActivityCompat.requestPermissions(this, permissions, REQUEST_RECORD_AUDIO_PERMISSION);
        return;
    }
    
    // 启动系统录音应用
    Intent intent = new Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION);
    if (intent.resolveActivity(getPackageManager()) != null) {
        startActivityForResult(intent, REQUEST_RECORD_AUDIO_PERMISSION);
    } else {
        Toast.makeText(this, "No recording app found", Toast.LENGTH_SHORT).show();
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_RECORD_AUDIO_PERMISSION && resultCode == RESULT_OK && data != null) {
        Uri audioUri = data.getData();
        // 处理录音文件
        if (audioUri != null) {
            Toast.makeText(this, "Recording saved: " + audioUri.toString(), Toast.LENGTH_SHORT).show();
        }
    }
}

大多数App其实是都是内部支持录音,比如微信就不可能跳转到外面录音啊.

private void checkAndStartRecording() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) 
            != PackageManager.PERMISSION_GRANTED || 
        ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) 
            != PackageManager.PERMISSION_GRANTED) {
        
        ActivityCompat.requestPermissions(this, 
            new String[]{
                Manifest.permission.RECORD_AUDIO,
                Manifest.permission.WRITE_EXTERNAL_STORAGE
            }, 
            REQUEST_PERMISSION_CODE);
    } else {
        startRecording();
    }
}

private void startRecording() {
    try {
        // 创建输出文件
        outputFile = getExternalCacheDir().getAbsolutePath() + "/recording.3gp";
        
        mediaRecorder = new MediaRecorder();
        mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
        mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
        mediaRecorder.setOutputFile(outputFile);
        mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
        
        mediaRecorder.prepare();
        mediaRecorder.start();
        isRecording = true;
        Toast.makeText(this, "Recording started", Toast.LENGTH_SHORT).show();
    } catch (IOException e) {
        Log.e("MediaRecorder", "Recording failed", e);
        releaseMediaRecorder();
    }
}

private void stopRecording() {
    if (isRecording) {
        mediaRecorder.stop();
        isRecording = false;
        Toast.makeText(this, "Recording saved to " + outputFile, Toast.LENGTH_LONG).show();
    }
    releaseMediaRecorder();
}

private void releaseMediaRecorder() {
    if (mediaRecorder != null) {
        mediaRecorder.release();
        mediaRecorder = null;
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == REQUEST_PERMISSION_CODE) {
        if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            startRecording();
        } else {
            Toast.makeText(this, "Permission denied", Toast.LENGTH_SHORT).show();
        }
    }
}

@Override
protected void onStop() {
    super.onStop();
    releaseMediaRecorder();
}

播放音乐也是同理的.

private void playAudioWithMediaPlayer(String audioPath) {
    try {
        if (mediaPlayer == null) {
            mediaPlayer = new MediaPlayer();
        } else {
            mediaPlayer.reset();
        }
        
        mediaPlayer.setDataSource(audioPath); // 可以是本地文件路径或网络URL
        mediaPlayer.prepareAsync(); // 异步准备
        
        mediaPlayer.setOnPreparedListener(mp -> {
            mp.start(); // 准备好后开始播放
            Log.d("MediaPlayer", "Duration: " + mp.getDuration() + "ms");
        });
        
        mediaPlayer.setOnCompletionListener(mp -> {
            releaseMediaPlayer();
            Log.d("MediaPlayer", "Playback completed");
        });
        
        mediaPlayer.setOnErrorListener((mp, what, extra) -> {
            releaseMediaPlayer();
            Log.e("MediaPlayer", "Playback error: " + what + ", " + extra);
            return true;
        });
    } catch (IOException e) {
        Log.e("MediaPlayer", "Playback failed", e);
        releaseMediaPlayer();
    }
}

private void releaseMediaPlayer() {
    if (mediaPlayer != null) {
        mediaPlayer.release();
        mediaPlayer = null;
    }
}

// 暂停播放
private void pausePlayback() {
    if (mediaPlayer != null && mediaPlayer.isPlaying()) {
        mediaPlayer.pause();
    }
}

// 继续播放
private void resumePlayback() {
    if (mediaPlayer != null && !mediaPlayer.isPlaying()) {
        mediaPlayer.start();
    }
}

@Override
protected void onDestroy() {
    super.onDestroy();
    releaseMediaPlayer();
}

使用MediaStore.ACTION_VIDEO_CAPTURE意图可以调起系统的拍照和录像,这里也不展开了,但是用CamerX可以在软件内部直接用相机,包括拍照和录像.

private void takePhoto() {
    // 创建输出文件
    File photoFile = new File(
        getOutputDirectory(),
        new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss-SSS").format(new Date()) + ".jpg"
    );
    
    ImageCapture.OutputFileOptions outputFileOptions =
        new ImageCapture.OutputFileOptions.Builder(photoFile).build();
    
    imageCapture.takePicture(
        outputFileOptions,
        ContextCompat.getMainExecutor(this),
        new ImageCapture.OnImageSavedCallback() {
            @Override
            public void onImageSaved(@NonNull ImageCapture.OutputFileResults outputFileResults) {
                String savedUri = photoFile.getAbsolutePath();
                Toast.makeText(MainActivity.this, "Photo saved: " + savedUri, Toast.LENGTH_SHORT).show();
            }
            
            @Override
            public void onError(@NonNull ImageCaptureException exception) {
                Log.e("CameraX", "Photo capture failed: " + exception.getMessage(), exception);
            }
        }
    );
}

之前说的播放都要求资源在本地,还有一个轮子叫ExoPlayer就支持网络流,各种动态加载都很方便.这一次学习很多已经是调包的过程了,虽然看起来技术含量不高,但是需要反复实践.