开发实践中遇到的一些问题及答案(Android篇五)

又至冬日

已于 2023-06-07 15:10:53 修改

阅读量148

点赞数

文章标签： android java 开发语言

于 2023-05-29 13:40:30 首次发布

本文链接：https://blog.csdn.net/qq_55805329/article/details/130926452

版权

Some problems encountered and their answers in work (Android Chapter)

在Android应用程序中，可以使用Java代码执行shell命令并防止InputStream和ErrorStream阻塞

String command = "ls -l";
Process process = Runtime.getRuntime().exec(command);
BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
BufferedReader errorReader = new BufferedReader(new InputStreamReader(process.getErrorStream()));

// 创建两个线程来读取输入流和错误流，以避免阻塞主线程
Thread inputThread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            int read;
            char[] buffer = new char[4096];
            StringBuffer output = new StringBuffer();
            while ((read = reader.read(buffer)) > 0) {
                output.append(buffer, 0, read);
            }
            reader.close();
            String outputText = output.toString();
            // 处理输出
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
inputThread.start();

Thread errorThread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            int read;
            char[] buffer = new char[4096];
            StringBuffer output = new StringBuffer();
            while ((read = errorReader.read(buffer)) > 0) {
                output.append(buffer, 0, read);
            }
            errorReader.close();
            String outputText = output.toString();
            // 处理错误输出
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
});
errorThread.start();

// 等待进程完成
int exitCode = process.waitFor();

// 处理退出码
这个示例代码将执行ls -l命令，并启动两个线程来读取命令的输出和错误输出。这避免了主线程的阻塞。请注意，waitFor()方法将阻塞主线程，直到进程完成执行为止。

在处理线程中，你可以将读取的输出存储在变量中，并在主线程中对其进行处理。另外，请记住，在处理错误输出时，可能需要采取额外的措施来确保应用程序不会出现故障或崩溃。

在一个有多内容的ScrollView的中间有一个LinearLayout布局，当在代码中通过一个开关控制LinearLayout显示隐藏时，ScrollView总是会自动滑动到顶部，而不是保持在原始位置

这可能是由于控制LinearLayout显示/隐藏时，焦点发生变化导致的。你可以在控制LinearLayout显示/隐藏时设置ScrollView的焦点位置，以保持滚动位置不变。具体方法如下：
 1. 在XML文件中，为ScrollView设置一个唯一的ID：
<ScrollView
    android:id="@+id/my_scroll_view"
    …
    >
    <LinearLayout
        …
        >
        // 这里放置你的内容
    </LinearLayout>
</ScrollView>
2. 在Java代码中，获取ScrollView的实例，并在控制LinearLayout显示/隐藏时设置它的焦点位置：
ScrollView scrollView = findViewById(R.id.my_scroll_view);
 // 显示LinearLayout
linearLayout.setVisibility(View.VISIBLE);
scrollView.post(new Runnable() {
    @Override
    public void run() {
        scrollView.scrollTo(0, linearLayout.getTop());
    }
});
 // 隐藏LinearLayout
linearLayout.setVisibility(View.GONE);
scrollView.post(new Runnable() {
    @Override
    public void run() {
        scrollView.scrollTo(0, 0);
    }
});
其中，
scrollView.post()
方法可以让设置焦点位置的任务在ScrollView完成绘制后再执行，确保焦点位置被正确设置。

方法二

这个问题可能是由于控制LinearLayout的可见性时，给ScrollView设置了新的子视图导致的。可以尝试使用如下解决方案来保持ScrollView的滚动位置不变：
1. 记录当前ScrollView的滚动位置：
int scrollY = scrollView.getScrollY();
2. 设置LinearLayout的可见性：
linearLayout.setVisibility(View.VISIBLE); // 或者 View.GONE
3. 添加LinearLayout到ScrollView中：
scrollView.addView(linearLayout);
4. 恢复ScrollView的滚动位置：
scrollView.post(new Runnable() {
    @Override
    public void run() {
        scrollView.scrollTo(0, scrollY);
    }
});

在一个有多内容的ScrollView布局，当在代码中改变其中一个组件的显示隐藏状态时，这时ScrollView高度发生变化并且总是会自动跳到顶部

这个问题可能是因为在改变组件的可见性时，ScrollView重新计算了它的高度，从而导致它滚动到了顶部。你可以尝试以下解决方案来保持原来的滚动位置：
1. 在你的ScrollView上添加以下属性，以确保ScrollView的滚动位置被正确记住：
<ScrollView
    ...
    android:saveEnabled="true"
    android:isScrollContainer="false"
    ...
    >
    ...
</ScrollView>
2. 在Java代码中，获取ScrollView的实例，并获取当前滚动的Y位置：
ScrollView scrollView = findViewById(R.id.my_scroll_view);
int scrollY = scrollView.getScrollY();
3. 在修改组件的可见性之后，使用下面的代码将滚动位置恢复到原来的位置：
scrollView.post(new Runnable() {
    @Override
    public void run() {
        scrollView.scrollTo(0, scrollY);
    }
});

利用以上方法，会有一个滑到顶部又滑下来的过程该如何处理

在使用方法时，可能会出现滑到顶部又滑下来的情况是因为 ScrollView 在恢复可见性变化后的滚动位置时可能会有一定的延迟，导致用户会看到一段滑到顶部又滑下来的过程。你可以尝试以下两种解决方案：
 1. 在设置可见性之前获取 ScrollView 的当前滚动位置，并记录下来。在设置完可见性后，使用下面的代码将 ScrollView 恢复到原来的位置：
ScrollView scrollView = findViewById(R.id.my_scroll_view);
int scrollY = scrollView.getScrollY();
 // 隐藏组件
linearLayout.setVisibility(View.GONE);
 // 恢复 ScrollView 的滚动位置
scrollView.smoothScrollTo(0, scrollY);
使用  `smoothScrollTo()`  方法可能会在滚动过程中出现一些延迟，但是这种方式可以避免一开始出现滑到顶部又滑下来的情况。
 2. 在设置完可见性之后，使用  `postDelayed()`  方法来将 ScrollView 恢复到原来的位置，以此来避免滑到顶部又滑下来的情况：
ScrollView scrollView = findViewById(R.id.my_scroll_view);
 // 隐藏组件
linearLayout.setVisibility(View.GONE);
 // 在一定时间间隔后恢复 ScrollView 的滚动位置
scrollView.postDelayed(new Runnable() {
  @Override
  public void run() {
    scrollView.scrollTo(0, scrollY);
  }
}, 200);
使用  `postDelayed()`  方法会在一定时间间隔后再将 ScrollView 恢复到原来的位置，这样就可以避免滑到顶部又滑下来的情况了，但是需要注意的是这个时间间隔需要根据具体情况来调整，以确保用户不会看到滑动过程。

Android 如何开启一个子线程

在 Android 应用程序中，可以使用多种方式开启一个子线程，以下是其中两种常用的方式：
 1. 使用 Thread 类创建子线程
 可以使用 Thread 类来创建一个新的线程，然后在该线程中执行我们需要执行的任务。以下是一个使用 Thread 类创建子线程的示例代码：
new Thread(new Runnable() {
    @Override
    public void run() {
        // 在这里执行我们需要在子线程中执行的任务
    }
}).start();
在这个例子中，我们首先创建了一个 Runnable 对象，并在其中实现了我们需要在子线程中执行的任务。然后，我们将这个 Runnable 对象传递给了 Thread 类的构造函数中，创建了一个新的线程。最后，我们调用了 start() 方法来启动这个线程，并在该线程中执行我们的任务。
 2. 使用 AsyncTask 类创建子线程
 除了使用 Thread 类之外，还可以使用 AsyncTask 类来创建一个子线程，这个类可以更方便地在子线程中执行异步任务，并在任务执行完成后将结果返回给主线程。以下是一个使用 AsyncTask 类创建子线程的示例代码：
private class MyTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... voids) {
        // 在这里执行我们需要在子线程中执行的任务
        return null;
    }
     @Override
    protected void onPostExecute(Void aVoid) {
        // 在这里执行任务完成后需要在主线程中执行的代码
        super.onPostExecute(aVoid);
    }
}
 // 在需要开启子线程的地方创建并启动 AsyncTask
new MyTask().execute();
在这个示例中，我们首先定义了一个 MyTask 类来继承 AsyncTask 类，并重写了 doInBackground() 方法来实现我们需要在子线程中执行的任务。在任务执行完成后，我们还可以重写 onPostExecute() 方法来执行任务完成后需要在主线程中执行的代码。最后，在需要开启子线程的地方创建 MyTask 对象，并调用其 execute() 方法来启动这个异步任务。
 以上是两种常用的在 Android 应用程序中开启子线程的方式，你可以根据实际开发需求来选择使用哪种方式。

Android 获取经纬度及卫星数量（2）

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;

public class MainActivity extends AppCompatActivity implements LocationListener {

    private LocationManager locationManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 获取 LocationManager 实例
        locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);

        // 检查是否已经授权定位权限
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED) {
            // 注册 LocationListener 监听器
            locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
        } else {
            // 请求授权定位权限
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    1);
        }
    }

    @Override
    public void onLocationChanged(Location location) {
        // 当位置变化时回调该方法
        double latitude = location.getLatitude();  // 获取纬度
        double longitude = location.getLongitude();  // 获取经度
        int satellites = location.getExtras().getInt("satellites");  // 获取卫星数量
        // TODO: 处理位置信息
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        if (requestCode == 1 && grantResults.length > 0
                && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // 用户授权定位权限，注册 LocationListener 监听器
            locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);
        }
    }

    @Override
    public void onProviderEnabled(String provider) {}

    @Override
    public void onProviderDisabled(String provider) {}

    @Override
    public void onStatusChanged(String provider, int status, Bundle extras) {}
}

Android SurfaceView与TextureView区别

Android SurfaceView 与 TextureView 的区别如下：
 1. 渲染机制不同
SurfaceView 使用双缓冲机制，也就是说，它有两个独立的 Surface，一个 Surface 用于显示，另一个 Surface 用于绘制。通过一个线程不停地在后台绘制，并在绘制完成后将其提交到显示 Surface 上，来实现画面的渲染。而 TextureView 则直接将绘制的纹理作为显存中的一个部分，而不需要额外的缓存。
 2. 支持的使用场景不同
SurfaceView 适用于频繁更新的画面，比如视频播放、相机预览等，因为它可以在一个专门的线程中进行渲染，不会阻塞主线程。而 TextureView 则更适合于静态更新的画面，比如用于显示图像、动画、3D 游戏等，并且支持 Alpha 渐变和混合模式。
 3. 使用方式不同
SurfaceView 需要在 XML 文件中定义一个 SurfaceView，然后在代码中获取 SurfaceHolder 对象并通过它来控制 Surface 的绘制。而 TextureView 则可以直接在 XML 文件中定义并使用，通过 setSurfaceTextureListener() 方法来监听纹理的创建和销毁事件，并在回调函数中进行绘制。
 4. 可以使用的 API 不同
TextureView 支持 OpenGL ES 的渲染，可以使用 SurfaceTexture 对象来实现高性能的视频播放或 3D 渲染，而 SurfaceView 则只能通过 SurfaceHolder 与 Canvas 进行交互。
 总的来说，SurfaceView 适合于频繁更新的画面，而 TextureView 更适合于静态更新的画面，并且支持 OpenGL ES。选择哪一种视图控件应该根据实际使用场景来进行考虑。
 
 Android SurfaceView 与 TextureView 的优缺点如下：
 SurfaceView 优点：
1. 适用于频繁更新的画面，可以在专门的线程中进行渲染，不会阻塞主线程。
2. 支持硬件加速，可以使用 OpenGL ES 渲染。
3. 防止视图的重绘，提高了绘制效率。
4. 支持 SurfaceHolder.Callback 接口，可以通过回调函数进行监听和控制 Surface 的创建和销毁。
 SurfaceView 缺点：
1. 窗口管理器无法管理 SurfaceView，需要手动控制位置和大小。
2. 需要在一个专门的线程中进行渲染，线程与主线程之间的通信需要进行同步处理，增加了开发难度。
3. 不支持 Alpha 渐变和混合模式，无法实现一些高级的绘制效果。
 TextureView 优点：
1. 支持硬件加速，可以使用 OpenGL ES 渲染，支持 Alpha 渐变和混合模式，可以实现高级的绘制效果。
2. 可以通过 setSurfaceTextureListener() 方法监听纹理的创建和销毁事件，方便控制绘制过程。
3. 可以轻松地在 XML 文件中定义和使用，无需手动控制位置和大小。
 TextureView 缺点：
1. 不适用于频繁更新的画面，不能在专门的线程中进行渲染，需要防止在主线程中过度绘制从而导致卡顿。
2. 可能会造成内存泄漏，需要在适当的时候销毁 SurfaceTexture 对象。
3. 因为不支持双缓冲机制，所以可能会出现绘制卡顿现象。
 综合来看，两个组件都有自己的优缺点，应该根据实际的需求来选择合适的组件。

Android SurfaceView及TextureView对比

SurfaceView本质是一个View，与View不同的是他有自己的Surface，再WMS中有自己独立的WindowState，因此他不受View属性的控制，不支持平移、缩放等变换，也不能放在其它ViewGroup中，一些View中的特性也无法使用。
SurfaceView优点及缺点
优点：可以在一个独立的线程中进行绘制，不会影响主线程、 使用双缓冲机制，播放视频时画面更流畅

缺点：Surface不在View hierachy中，它的显示也不受View的属性控制，所以不能进行平移，缩放等变换，也不能放在其它ViewGroup中。SurfaceView 不能嵌套使用

双缓冲：在运用时可以理解为：SurfaceView在更新视图时用到了两张Canvas，一张frontCanvas和一张backCanvas，每次实际显示的是frontCanvas，backCanvas存储的是上一次更改前的视图，当使用lockCanvas（）获取画布时，得到的实际上是backCanvas而不是正在显示的frontCanvas，之后你在获取到的backCanvas上绘制新视图，再unlockCanvasAndPost（canvas）此视图，那么上传的这张canvas将替换原来的frontCanvas作为新的frontCanvas，原来的frontCanvas将切换到后台作为backCanvas。例如，如果你已经先后两次绘制了视图A和B，那么你再调用lockCanvas（）获取视图，获得的将是A而不是正在显示的B，之后你讲重绘的C视图上传，那么C将取代B作为新的frontCanvas显示在SurfaceView上，原来的B则转换为backCanvas。

TextureView是什么
在4.0(API level 14)中引入，与SurfaceView一样继承View，它可以将内容流直接投影到View中，可以用于实现Live preview等功能。和SurfaceView不同，它不会在WMS中单独创建窗口，而是作为View hierachy中的一个普通View，因此可以和其它普通View一样进行移动，旋转，缩放，动画等变化。值得注意的是TextureView必须在硬件加速的窗口中。它显示的内容流数据可以来自App进程或是远端进程。从类图中可以看到，TextureView继承自View，它与其它的View一样在View hierachy中管理与绘制。TextureView重载了draw()方法，其中主要SurfaceTexture中收到的图像数据作为纹理更新到对应的HardwareLayer中。SurfaceTexture.OnFrameAvailableListener用于通知TextureView内容流有新图像到来。SurfaceTextureListener接口用于让TextureView的使用者知道SurfaceTexture已准备好，这样就可以把SurfaceTexture交给相应的内容源。Surface为BufferQueue的Producer接口实现类，使生产者可以通过它的软件或硬件渲染接口为SurfaceTexture内部的BufferQueue提供graphic buffer。
TextureView优点及缺点
优点：支持移动、旋转、缩放等动画，支持截图
缺点：必须在硬件加速的窗口中使用，占用内存比SurfaceView高，在5.0以前在主线程渲染，5.0以后有单独的渲染线程。

Android 原生的恢复出厂设置回重置系统时间吗

Android 原生的恢复出厂设置会重置系统时间。恢复出厂设置会清除所有用户数据、应用程序、设置和配置，将设备恢复到出厂默认状态，包括系统时间。

HandlerThread handlerThread = new HandlerThread("111"); 
        handlerThread.start(); 
        Handler handler = new Handler(handlerThread.getLooper()){ 
            @Override 
            public void handleMessage(@NonNull Message msg) { 
                super.handleMessage(msg); 
            } 
        };
  
 1. 首先，创建一个名为"111"的HandlerThread线程对象并启动它： `HandlerThread handlerThread = new HandlerThread("111"); handlerThread.start();` 。
 2. 然后，创建一个Handler对象并将其绑定到该线程的消息队列中： `Handler handler = new Handler(handlerThread.getLooper()){...}` 。这样，我们就可以使用该Handler对象向该线程发送消息，并在该线程中处理这些消息。
 3. 在该Handler对象的 `handleMessage()` 方法中，我们可以根据不同的消息类型执行不同的操作。在本例中，由于没有定义任何消息类型，因此该方法为空。
 总之，以上代码演示了如何使用HandlerThread和Handler在Android平台上创建一个新的线程，并实现线程与主线程之间的通信。

HandlerThread handlerThread = new HandlerThread("111"); 
        handlerThread.start(); 
        Handler handler = new Handler(handlerThread.getLooper()){ 
            @Override 
            public void handleMessage(@NonNull Message msg) { 
                super.handleMessage(msg); 
            } 
 };

Handler handler = new Handler(Looper.getMainLooper()){ 
            @Override 
            public void handleMessage(@NonNull Message msg) { 
                super.handleMessage(msg); 
            } 
};
以俩种代码有何不同

以上两段代码的主要区别在于它们创建Handler对象时所使用的Looper对象不同，因此它们所绑定的消息队列也不同。
 1.  `HandlerThread handlerThread = new HandlerThread("111"); handlerThread.start(); Handler handler = new Handler(handlerThread.getLooper()){...}` ：这段代码创建了一个名为"111"的HandlerThread线程，并通过 `handlerThread.getLooper()` 方法获取了该线程的消息队列Looper对象，然后将该Looper对象传递给Handler对象进行绑定。因此，该Handler对象的消息队列与"111"线程的消息队列是同一个，即所有通过该Handler对象发送的消息都会被发送到"111"线程的消息队列中进行处理。
 2.  `Handler handler = new Handler(Looper.getMainLooper()){...}` ：这段代码创建了一个Handler对象，并通过 `Looper.getMainLooper()` 方法获取了主线程的消息队列Looper对象，然后将该Looper对象传递给Handler对象进行绑定。因此，该Handler对象的消息队列与主线程的消息队列是同一个，即所有通过该Handler对象发送的消息都会被发送到主线程的消息队列中进行处理。
 综上所述，这两段代码的主要区别在于它们所绑定的消息队列不同，前者绑定的是一个新的线程的消息队列，后者绑定的是主线程的消息队列。因此，前者可以用于在新的线程中执行耗时操作，而后者则用于在主线程中更新UI界面。

又至冬日

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
开发实践中遇到的一些问题及答案(Android篇五)

Java代码执行shell命令并防止InputStream和ErrorStream阻塞；在代码中控制ScrollView布局中某一控件的状态(显示隐藏)，ScrollView自动跳转顶部；Android 如何开启一个子线程；Android 获取经纬度及卫星数量（2）；Android SurfaceView与TextureView区别；
复制链接

扫一扫