【Android】应用数据及文件(更新)

已于 2023-06-26 14:04:22 修改
阅读量185 收藏
点赞数
分类专栏： Android基础 Android原生开发 文章标签： android java
于 2023-06-24 11:05:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sheng_er_sheng/article/details/131348897
版权

资料

https://developer.android.google.cn/training/data-storage/app-specific?hl=zh-cn

MindMap

在这里插入图片描述

planuml

见代码plantuml

代码

https://gitee.com/hellosunshine/application_data_storage.git

文章目录

存储路径获取
getFilesDir();
getCacheDir();
getExternalFilesDir("mp4");
getExternalCacheDir();
获取文件
File file = new File(context.getFilesDir(), fileName);
通过文件流写入文件
///信息流存储文件
    private void writeToApplicationDirFile(Context context) throws IOException {
        String fileContents = "Hello world! 你好";
        try (FileOutputStream fos = context.openFileOutput(fileName, Context.MODE_PRIVATE)) {
            fos.write(fileContents.getBytes());
        }
    }
信息流访问文件内容
///信息流访问文件
    private void readFromApplicationDirFile(Context context) throws FileNotFoundException {
        FileInputStream fis = context.openFileInput(fileName);
        InputStreamReader inputStreamReader = new InputStreamReader(fis, StandardCharsets.UTF_8);
        StringBuilder stringBuilder = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(inputStreamReader)) {
            String line = reader.readLine();
            while (line != null) {
                stringBuilder.append(line).append('\n');
                line = reader.readLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            String contents = stringBuilder.toString();
        }
    }
查看文件列表
///查看文件列表
    private void getFileList(Context context) {
        String[] files = context.fileList();
        for (String file : files) {

        }

    }
创建潜逃目录
///创建嵌套目录
    private void createFileDir(Context context) {
        File directory = context.getFilesDir();
        File file = new File(directory, fileName);
    }
缓存文件
///创建缓存文件
    private File createFileCache(Context context) throws IOException {
        return File.createTempFile(fileName, null, context.getCacheDir());
    }

    ///移除缓存文件
    private void deleteCacheFile(File cacheFile) {
        boolean result = cacheFile.delete();
    }

    ///移除缓存文件
    private void deleteCacheFileByName(Context context) {
        boolean result = context.deleteFile(fileName);
    }
检查外部存储控件是否可以读写文件
///检查外部存储空间中是否可以读写文件
    private boolean isExternalStorageWritable() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

    ///至少可以读文件
    private boolean isExternalStorageReadable() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) || Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY);
    }
选择物理存储位置
///选择物理存储位置
    private void choosePhysicStorage() {
        File[] externalStorageVolumes = ContextCompat.getExternalFilesDirs(getApplicationContext(), null);
        File primaryExternalStorage = externalStorageVolumes[0];
    }
访问持久性文件
///访问持久性文件
    private void getExternalFileDir(Context context) {
        File appSpecificExternalDir = new File(context.getExternalFilesDir(null), fileName);
    }
创建缓存文件
private void createCacheFile(Context context) {
        File externalCacheFile = new File(context.getExternalCacheDir(), fileName);
    }
媒体内容
File getAppSpecificAlbumStorageDir(Context context, String albumName) {
        File file = new File(context.getExternalFilesDir(Environment.DIRECTORY_PICTURES), albumName);
        if (!file.mkdirs()) {
            Log.e(TAG, "Directory not created");
        }
        return file;
    }
查询可用空间
private void searchDevicesAvailable() throws IOException {
        long NUM_BYTES_NEEDED_FOR_MY_APP = 1024 * 1024 * 10L;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            StorageManager storageManager = getApplicationContext().getSystemService(StorageManager.class);
            UUID appSpecificInternalDirUuid = storageManager.getUuidForPath(getFilesDir());
            ///可用空间
            long availableBytes = storageManager.getAllocatableBytes(appSpecificInternalDirUuid);
            if (availableBytes >= NUM_BYTES_NEEDED_FOR_MY_APP) {
                storageManager.allocateBytes(appSpecificInternalDirUuid, NUM_BYTES_NEEDED_FOR_MY_APP);
            } else {
                ///管理存储，释放空间
                Intent storageIntent = new Intent();
                storageIntent.setAction(ACTION_MANAGE_STORAGE);
                startActivity(storageIntent);
            }
        }
    }
显示设备上可用空间量
private void showAllocatedSpace() throws IOException {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            StorageStatsManager storageStatsManager = (StorageStatsManager) getSystemService(Context.STORAGE_STATS_SERVICE);
            StorageManager storageManager = getApplicationContext().getSystemService(StorageManager.class);
            UUID appSpecificInternalDirUuid = storageManager.getUuidForPath(getFilesDir());
            long freeBytes = storageStatsManager.getFreeBytes(appSpecificInternalDirUuid);
            long totalBytes = storageStatsManager.getTotalBytes(appSpecificInternalDirUuid);
            double value = (float) freeBytes / totalBytes;
            Toast.makeText(getApplicationContext(), String.valueOf(value), Toast.LENGTH_LONG).show();
        }
    }
移除所有缓文件
///移除所有缓文件
    @RequiresApi(api = Build.VERSION_CODES.R)
    private void clearAllCache() {
        Intent intent = new Intent();
        intent.setAction(ACTION_CLEAR_APP_CACHE);
        startActivityForResult(intent, 1000);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        if (requestCode == 1000) {
            Toast.makeText(getApplicationContext(), "调用", Toast.LENGTH_LONG).show();
        }
        super.onActivityResult(requestCode, resultCode, data);
    }
访问共享媒体文件（MediaStore）
    ///媒体库
    private void getMediaStore() {
        String[] projection = new String[]{};
        String seleciton = "";
        String[] selectionArgs = new String[]{};
        String sortOrder = "";
        @SuppressLint("Recycle") Cursor cursor = getApplicationContext().getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
//                MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
//                MediaStore.Audio.Media.EXTERNAL_CONTENT_URI,
//                MediaStore.Downloads.EXTERNAL_CONTENT_URI,
//                MediaStore.Files,
                projection, seleciton, selectionArgs, sortOrder);
        while (cursor.moveToNext()) {

        }
    }
获取媒体库的版本
    ///获取媒体库的版本
    private void getVersion(Context context) {
        String v = MediaStore.getVersion(context);
    }
查询媒体集合（视频 & 图片）
///视频类
class Video {
    private final Uri uri;
    private final String name;
    private final int duration;
    private final int size;

    public Video(Uri uri, String name, int duration, int size) {
        this.uri = uri;
        this.name = name;
        this.duration = duration;
        this.size = size;
    }
}

///查询媒体集合（视频）
    private void queryMediaCollection(Context context) {
        List<Video> videoList = new ArrayList<>();
        Uri collection;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            collection = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL);
        } else {
            collection = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
        }
        String[] projection = new String[]{MediaStore.Video.Media._ID, MediaStore.Video.Media.DISPLAY_NAME, MediaStore.Video.Media.DURATION, MediaStore.Video.Media.SIZE, MediaStore.Video.Media.DATA,};
        String selection = MediaStore.Video.Media.DURATION + ">= ?";
        String[] selectionArgs = new String[]{String.valueOf(TimeUnit.MILLISECONDS.convert(1, TimeUnit.MINUTES))};
        String sortOrder = MediaStore.Video.Media.DISPLAY_NAME + " ASC";
        try (Cursor cursor = context.getContentResolver().query(collection, projection, selection, selectionArgs, sortOrder)) {
            int idColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media._ID);
            int nameColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DISPLAY_NAME);
            int durationColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DURATION);
            int sizeColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.SIZE);
            int dataColumn = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA);
            while (cursor.moveToNext()) {
                long id = cursor.getLong(idColumn);
                String name = cursor.getString(nameColumn);
                int duration = cursor.getInt(durationColumn);
                int size = cursor.getInt(sizeColumn);
                String path = cursor.getString(dataColumn);
                System.out.println(path);
                Uri contentUri = ContentUris.withAppendedId(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id);
                ///加载文件缩略图
                Bitmap bitmap = loadFileThumbnail(contentUri);
                ///打开媒体文件
                openMediaFile(contentUri);
                ///获取媒体的位置信息
                getVideoInfo(contentUri, context);
                ///原生代码更新
                remoteCodeUpdate(contentUri);
                videoList.add(new Video(contentUri, name, duration, size));
            }
            Toast.makeText(context, videoList.size() + "个", Toast.LENGTH_LONG).show();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    ///查询媒体集合（图片）
    private void queryPhotoCollection(Context context) {
        Uri collection;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            collection = MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL);
        } else {
            collection = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
        }
        String[] projection = new String[]{MediaStore.Images.Media._ID, MediaStore.Images.Media.DISPLAY_NAME, MediaStore.Images.Media.SIZE, MediaStore.Images.Media.DATA,};
        String sortOrder = MediaStore.Images.Media.DISPLAY_NAME + " ASC";
        try (Cursor cursor = context.getContentResolver().query(collection, projection, null, null, sortOrder)) {
            int idColumn = cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID);
            int nameColumn = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME);
            int sizeColumn = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.SIZE);
            int data = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            while (cursor.moveToNext()) {
                long id = cursor.getLong(idColumn);
                String name = cursor.getString(nameColumn);
                int size = cursor.getInt(sizeColumn);
                Uri contentUri = ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id);
                String path = cursor.getString(data);
                ///获取媒体的拍摄位置
                getPhotoInfo(contentUri);
            }
        }
    }
获取媒体的缩略图
///加载文件缩略图
    private Bitmap loadFileThumbnail(Uri contentUri) throws IOException {
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
            return getApplicationContext().getContentResolver().loadThumbnail(contentUri, new Size(640, 480), null);
        }
        return null;
    }
打开媒体文件
    ///打开媒体文件
    private void openMediaFile(Uri contentUri) throws IOException {
        ContentResolver resolver = getApplicationContext().getContentResolver();
        //rw 读和写; rwt 覆盖已有的文件
        String readOnlyMode = "r";
        //文件描述符
        try (ParcelFileDescriptor parcelFileDescriptor = resolver.openFileDescriptor(contentUri, readOnlyMode)) {

        } catch (IOException e) {
            e.printStackTrace();
        }
        //文件流
        try (InputStream stream = resolver.openInputStream(contentUri)) {

        }
    }
查看其他分卷
    ///查看其他分卷
    private void checkOutOtherVolume(Context context) {
        Set<String> volumeNames = null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
            volumeNames = MediaStore.getExternalVolumeNames(context);
            String firstVolumeName = volumeNames.iterator().next();
        }
    }
获取媒体的拍摄位置(图片 & 视频)
///获取媒体的拍摄位置(图片)
    private void getPhotoInfo(Uri photoUri) {
        float[] latLong = new float[2];
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            photoUri = MediaStore.setRequireOriginal(photoUri);
            InputStream stream = null;
            try {
                stream = getApplicationContext().getContentResolver().openInputStream(photoUri);
                if (stream != null) {
                    ExifInterface exifInterface = new ExifInterface(stream);
                    boolean returnedLatLong = exifInterface.getLatLong(latLong);
                    if (returnedLatLong) {
                        float la = latLong[0];
                        float lo = latLong[1];
                    } else {
                        latLong = new float[2];
                    }
                    stream.close();
                } else {
                    latLong = new float[2];
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        } else {
            latLong = new float[2];
        }
    }

    //获取媒体的位置信息
    private void getVideoInfo(Uri videoUri, Context context) {
        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
        try {
            retriever.setDataSource(context, videoUri);
        } catch (RuntimeException e) {
            e.printStackTrace();
        }
        String locationMetadata = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_LOCATION);
    }
添加媒体
//添加媒体到媒体库中
    private Uri addMedia() {
        ContentResolver resolver = getApplicationContext().getContentResolver();
        Uri videoCollection;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            videoCollection = MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
        } else {
            videoCollection = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
        }
        ContentValues newSongDetails = new ContentValues();
        Random random = new Random();
        double number = random.nextInt(1000);
        newSongDetails.put(MediaStore.Video.Media.DISPLAY_NAME, "My Video" + number + ".mp4");
        Uri uri = resolver.insert(videoCollection, newSongDetails);
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            try(Cursor cursor = getApplicationContext().getContentResolver().query(uri, new String[] {MediaStore.Video.Media.DATA}, null, null)) {
                int data = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
                while (cursor.moveToNext()) {
                    System.out.println(cursor.getString(data));
                }
            }
        }
        return uri;
    }

    ///耗时操作写入媒体
    @RequiresApi(api = Build.VERSION_CODES.Q)
    private void addMediaWithinLongTime() {
        ContentResolver resolver = getApplicationContext().getContentResolver();
        Uri audioCollection;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            audioCollection = MediaStore.Audio.Media.getContentUri(MediaStore.VOLUME_EXTERNAL_PRIMARY);
        } else {
            audioCollection = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
        }

        ContentValues songDetails = new ContentValues();
        songDetails.put(MediaStore.Audio.Media.DISPLAY_NAME, "My Workout Playlist.mp3");
        songDetails.put(MediaStore.Audio.Media.IS_PENDING, 1);

        Uri songContentUri = resolver.insert(audioCollection, songDetails);

        try (ParcelFileDescriptor pfd = resolver.openFileDescriptor(songContentUri, "w", null)) {
        } catch (IOException e) {
            e.printStackTrace();
        }
        songDetails.clear();
        songDetails.put(MediaStore.Audio.Media.IS_PENDING, 0);
        resolver.update(songContentUri, songDetails, null, null);
    }
更新媒体
///更新项目(自己app创建的可以修改)
    private void updateProject(Uri uri) {
        ContentResolver resolver = getApplicationContext().getContentResolver();
        ContentValues updatedSongDetails = new ContentValues();
        updatedSongDetails.put(MediaStore.Video.Media.DISPLAY_NAME, "My Favorite video.mp4");
        try (ParcelFileDescriptor pfd = resolver.openFileDescriptor(uri, "w", null)) {
            String path = uri.getPath();
            int numSongsUpdated = resolver.update(uri, updatedSongDetails, null, null);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
原生代码更新
///原生代码更新
    private void remoteCodeUpdate(Uri contentUri) throws FileNotFoundException {
        ContentResolver resolver = getApplicationContext().getContentResolver();
        String fileOpenMode = "r";
        @SuppressLint("Recycle") ParcelFileDescriptor parcelFd = resolver.openFileDescriptor(contentUri, fileOpenMode);
        if (parcelFd != null) {
            int fd = parcelFd.detachFd();
            // Pass the integer value "fd" into your native code. Remember to call
            // close(2) on the file descriptor when you're done using it.
        }
    }
删除媒体
    ///删除媒体
    private void deleteMedia(Uri uri) {
        ContentResolver contentResolver = getApplicationContext().getContentResolver();
        String selection = "";
        String[] selectionArgs = {""};
        int numImagesRemoved = contentResolver.delete(uri, selection, selectionArgs);
    }
检查媒体文件的更新
    ///检查媒体文件的更新
    private void checkMediaUpdate(Context context, String volumeName) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            long number = MediaStore.getGeneration(context, volumeName);
        }
    }
管理媒体文件组 createWriteRequest()
///管理媒体文件组 createWriteRequest()
    private void manageMediaGroupCreateWriteRequest(Uri uri) throws IntentSender.SendIntentException {

        ContentResolver contentResolver = getApplicationContext().getContentResolver();
        List<Uri> urisToModify = new ArrayList<>();
        urisToModify.add(uri);
        PendingIntent editPendingIntent = null;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
            editPendingIntent = MediaStore.createWriteRequest(contentResolver, urisToModify);
            startIntentSenderForResult(editPendingIntent.getIntentSender(), EDIT_REQUEST_CODE, null, 0, 0, 0);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == EDIT_REQUEST_CODE) {
            if (resultCode == Activity.RESULT_OK) {
                /* Edit request granted; proceed. */
            } else {
                /* Edit request not granted; explain to the user. */
            }
        }
    }
sheng_er_sheng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Android应用自动更新代码实现
04-27
在Android应用开发中，为了确保用户始终使用最新版本的应用，开发者通常会实现自动更新功能。本文将详细探讨如何在Android应用程序中实现自动检查并下载新版本的代码逻辑，以达到无缝更新的效果。 首先，我们需要一...
Android 媒体库数据更新方法总结
01-05
Android 媒体库数据更新方法总结 在项目中，我们经常要创建个自己的目录，里面存放一些图片啊文件之类，比如：我在SD卡中刚创建了一个文件夹A，里面放入了照片B，那么，这个时候我立马去Gallery里面查看这个目录里的...
Android 10(Q)_11(R) 分区存储适配，安卓开发基础面试题
m0_60707708的博客
03-23 970
如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。GitHub地址PS：我GitHub中有大量高阶Android学习视频资料和面试资料包~如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。[外链图片转存中…(img-S71UQGjG-1711131567371)]GitHub地址PS：我GitHub中有大量高阶Android学习视频资料和面试资料包~欢迎大家一起交流讨论啊~
Android-存储空间的最佳实践，Android跨进程通信导论
2401_84150191的博客
04-06 1017
您需要根据运行应用的 Android 版本来整合逻辑。
Android存储之分区存储适配
XBlithe的博客
10-10 7368
在上文中我们了解到，外部存储空间分为私有目录和公共目录，在Android10以前，应用程序通过获取READ_EXTERNAL_STORAGE 和 WRITE_EXTERNAL_STORAGE 权限。获得外部存储空间的权限以后直接通过file path读取和修改外部存储空间中任意的文件，当然也包括其他应用的外部私有目录文件，这样一来极易造成泄露用户隐私。而且很多应用会在外部存储根目录建一个自己应用的文件夹，用于存放应用的数据。这样会导致用户卸载后，应用数据不会随之删除。导致手机文件特别混乱，长期占用空间。
Android R新特性：存储相关的更新
Proton
03-03 3407
Android 11进一步增强了平台，为外部存储上的应用程序和用户数据提供了更好的保护。作为这项工作的一部分，该平台引入了进一步的改进，以简化向范围存储的过渡。 该预览版引入了我们去年在Android Dev Summit上提出的一些增强功能，例如，对介质的选择加入原始文件路径访问，对介质的批处理编辑操作以及对Storage Access Framework的更新的UI。 在即将发布的Dev...
安卓11?快！扶我起来继续学
Zhujiang
04-20 1821
前言 安卓更新换代非常快，5.0之前版本更新的时间线有点看不懂，但5.0之后更新还是比较稳定的，大概一年更新一次，谷歌工程师对安卓每个版本的命名也有点意思，比如棒棒糖、棉花糖、奥利奥、馅饼啊啥的（命名的应该也是个吃货），还有，从1.5开始，之后的版本都按照英文字母顺序排列，从C开始，到现在的11排到了R。 2019年5月8日，谷歌在Google I/O 2019开发者大会上，正式公布了安卓10系统...
Android中清除应用数据的方法
wusj的博客
07-12 9284
Android 中应用的数据分为内置储存的和外置储存，默认是保存在内置储存的，所以一般清除内置储存的就行了。使用这个工具类： import java.io.File; public class DataCleanManager { public static void DeleteFile(File file) { if (file.exists() == false...
Android 获取应用签名
赵航的博客
12-01 6万+
本文主要讲下在android中如何获取应用签名. 也方便平时用来区分一个应用是不是原包应用.
Android - 文件存储
热门推荐
HugMua的博客
10-31 12万+
手动在/storage/sdcard下创建自定义文件夹，APP删除后不会删除存储在这里的数据。由于Android10中加入了作用域存储功能，
将Excel数据导入android数据库DB文件
02-28
本教程将指导你如何将Excel数据导入到Android应用的SQLite数据库.db文件中，以便在应用运行时能够访问和操作这些数据。我们将使用SQLite Expert Professional这款强大的SQLite数据库管理工具，该工具在提供的压缩包...
Android应用源码之数据存储.zip
09-03
在Android应用开发中，数据存储是一项至关重要的任务，它涉及到应用程序如何持久化用户数据、配置信息、偏好设置等。这份"Android应用源码之数据存储.zip"资源包含了一个关于Android应用如何实现数据存储的示例代码...
Android读写配置文件
10-29
在Android开发中，读写配置文件是常见的任务，主要用于存储应用程序的设置、用户偏好或者其他持久化数据。配置文件通常以XML或JSON格式存在，...理解并掌握这些技术，能有效提升Android应用的用户体验和功能完整性。
Android 存储空间的最佳实践 (上)
谷歌开发者
08-09 614
为了提高文件的规整程度并让用户可以更好地控制他们的文件，Android 10 为应用引入了名为 "分区存储"的新范式。分区存储改变了应用在外置存储中保存和访问文件的方式...
【Android系统启动】 Android Zygote 进程启动流程源码解析
thirdbro的博客
07-17 708
在 userdebug 版本中，如果 persist.debug.dalvik.vm.jdwp.enabled 为 1，则所有应用均可使用 JDWP 和 ptrace 进行调试。题外话， 之前找zygote源码的时候，本来想直接通过进程名找这个模块的源码，结果发现根本没有zygote这个名字的命令。通过命令查找到对应的进程目录发现，原来的进程的名字当时编译为。通过上面传下来的参数，“com.android.internal.os.ZygoteInit”，可以得知Java层的包名，以此找到Java代码。
【Android】视图与常用控件总结
Patrick_yuxuan的博客
07-17 950
属性名描述android:id为视图分配唯一的ID，用于在代码中引用设置视图的宽度设置视图的高度设置视图的外边距设置视图的内边距设置视图在其父视图中的对齐方式（仅适用于ViewGroup的子视图）设置视图内容的对齐方式设置视图的背景颜色或图片设置视图的可见性（visibleinvisiblegone设置视图在线性布局中的权重（仅适用于设置视图是否与父视图的顶部对齐（仅适用于设置视图是否与父视图的底部对齐（仅适用于设置视图是否在父视图中居中（仅适用于设置视图在另一视图的下面（仅适用于。
【23】Android高级知识之Window(四) - ThreadedRenderer
最新发布
mr_zengkun的博客
07-21 761
ThreadedRenderer、WMS
Android中接入hook框架：lancet-base
冰雪世界
07-21 100
me.ele:lancet-base是"饿了么"开发的Android平台的开源hook框架，GitHub地址为：https://github.com/eleme/lancet。 此框架的优点如下： 1.编译速度快, 并且支持增量编译。 2.简洁的 API, 几行 Java 代码完成注入需求。 3.没有任何多余代码插入 apk。 4.支持用于 SDK, 可以在SDK编写注入代码来修改依赖SDK的App。 接入me.ele:lancet-base框架的步骤如下： 1.在项目根目录的build.gradle
Android init.rc如何并行执行任务
netwalk的专栏
07-17 1090
在 Android 系统中，init.rc 是一个重要的启动脚本，用于定义系统启动时需要执行的服务、操作和初始化任务,也是用来配置系统启动时的各种服务、属性和动作的脚本文件。虽然 init.rc 文件本身是一个序列化的配置文件，init.rc 文件中的命令通常按顺序执行，但 Android 的 init 进程和 init.rc 文件中的机制允许一定程度的并行执行任务，通过特定的机制，Android 也支持并行执行 init.rc 中的命令。
Android 数据存储方法及应用场景总结
数据存储在手机应用平台软件开发中是一个重要的环节，Android平台提供了四种主要的数据存取方式：SharedPreferences、文件、SQLite数据库和ContentProvider。其中，SharedPreferences是一种轻量级的键-值方式存储，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sheng_er_sheng

打赏是什么？好吃么

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值