发表Android19 分钟读完 (大约2796个字)

Android Aidl 通信案例

01.aidl通信业务需求

  • aidl多进程通信应用
    • 服务端：某app；客户端：app调试工具。
    • 注意：aidl多进程通信是指两个独立app之间的通信……
  • 打开app调试工具(客户端)
    • 可以通过绑定服务端某app的service，获取到公司app的信息，比如渠道，版本号，签名，打包时间，token等属性
    • 通过app调试工具，可以通过aidl接口中的方法设置属性，设置成功后，查看某app是否设置属性成功
阅读更多
发表Android5 分钟读完 (大约756个字)

Android Aidl 基础介绍

01.什么是AIDL

  • AIDL 意思即 Android Interface Definition Language，翻译过来就是Android接口定义语言，是用于定义服务端和客户端通信接口的一种描述语言，可以拿来生成用于 IPC 的代码。从某种意义上说 AIDL 其实是一个模板，因为在使用过程中，实际起作用的并不是 AIDL 文件，而是据此而生成的一个 IInterface 的实例代码，AIDL 其实是为了避免我们重复编写代码而出现的一个模板
  • AIDL文件以 .aidl 为后缀名
阅读更多
发表Android9 分钟读完 (大约1317个字)

Android IPC 之 Messenger

01.Messenger基本概述

  • 除了使用 AIDL 进行 IPC 外，我们还可以使用 Messenger 来替代 AIDL。通过在 Message 对象中放入需要传递的对象，利用 Messenger 在不同进程间传递 Message 对象，就可以方便地进行进程间通信了

  • Messenger 是一种轻量级的 IPC 方案，底层实现依然是 AIDL，通过 Messenger 的两个构造方法就可以看出来

    1
    2
    3
    4
    5
    6
    7
    public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }

    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }
阅读更多
发表Android18 分钟读完 (大约2681个字)

Android IPC 之线程进程

01.前沿介绍

  • 默认情况下，Android 系统中同一应用的所有组件均运行在相同的进程和线程（称为主线程）中，新启动的应用组件会创建进程或者在已存在的进程中启动并使用相同的执行线程。
  • 但是，也可以安排应用中的组件在单独的进程中运行，并为任何进程创建额外的线程

02.Android中如何控件进程

阅读更多
发表Android12 分钟读完 (大约1734个字)

Android IPC 之序列化

01.什么是IPC

  • IPC（Inter-Process Communication）的含义即为进程间通信或者翻译为跨进程通信，是指两个进程之间进行数据交换的过程。
  • 一般情况下，在 Android系统中一个应用就只享有一个进程，在最简单的情况下一个进程可以只包含有一个线程（当然，一般情况下是不可能的），即主线程，也称为 UI 线程
  • 有时候应用因为某些原因需要采用多进程模式，此时如果要在应用内的不同进程间进行通信，就需要使用到 IPC 机制。或者是两个不同的应用需要进行数据交换，此时也一样需要依靠 Android 系统提供的 IPC 方案
阅读更多
发表Android23 分钟读完 (大约3519个字)

Android IPC 通信方式介绍

01.使用Intent

  • 1.Activity，Service，Receiver 都支持在 Intent 中传递 Bundle 数据，而 Bundle 实现了 Parcelable 接口，可以在不同的进程间进行传输。
  • 2.在一个进程中启动了另一个进程的 Activity，Service 和 Receiver ，可以在 Bundle 中附加要传递的数据通过 Intent 发送出去。

02.使用文件共享

阅读更多
发表Android9 分钟读完 (大约1418个字)

Android Log 源码介绍

1.关于Log源码介绍

  • Log对象，它位于android framework层utils包下，是一个final class类

    • 源码如下所示，可以看到其实final类，所以不能通过继承Log类的方式实现自身的日志工具类，一般可以通过定义Log成员变量的方式，封装Log工具方法。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    public final class Log {

        /**
         * Priority constant for the println method; use Log.v.
         */
        public static final int VERBOSE = 2;

        /**
         * Priority constant for the println method; use Log.d.
         */
        public static final int DEBUG = 3;

        /**
         * Priority constant for the println method; use Log.i.
         */
        public static final int INFO = 4;

        /**
         * Priority constant for the println method; use Log.w.
         */
        public static final int WARN = 5;

        /**
         * Priority constant for the println method; use Log.e.
         */
        public static final int ERROR = 6;

        /**
         * Priority constant for the println method.
         */
        public static final int ASSERT = 7;

        private Log() {
        }

        /**
         * Send a {@link #VERBOSE} log message.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         */
        public static int v(String tag, String msg) {
            return println(LOG_ID_MAIN, VERBOSE, tag, msg);
        }

        /**
         * Send a {@link #VERBOSE} log message and log the exception.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         * @param tr An exception to log
         */
        public static int v(String tag, String msg, Throwable tr) {
            return println(LOG_ID_MAIN, VERBOSE, tag, msg + '\n' + getStackTraceString(tr));
        }

        /**
         * Send a {@link #DEBUG} log message.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         */
        public static int d(String tag, String msg) {
            return println(LOG_ID_MAIN, DEBUG, tag, msg);
        }

        /**
         * Send a {@link #DEBUG} log message and log the exception.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         * @param tr An exception to log
         */
        public static int d(String tag, String msg, Throwable tr) {
            return println(LOG_ID_MAIN, DEBUG, tag, msg + '\n' + getStackTraceString(tr));
        }

        /**
         * Send an {@link #INFO} log message.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         */
        public static int i(String tag, String msg) {
            return println(LOG_ID_MAIN, INFO, tag, msg);
        }

        /**
         * Send a {@link #INFO} log message and log the exception.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         * @param tr An exception to log
         */
        public static int i(String tag, String msg, Throwable tr) {
            return println(LOG_ID_MAIN, INFO, tag, msg + '\n' + getStackTraceString(tr));
        }

        /**
         * Send a {@link #WARN} log message.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         */
        public static int w(String tag, String msg) {
            return println(LOG_ID_MAIN, WARN, tag, msg);
        }

        /**
         * Send a {@link #WARN} log message and log the exception.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         * @param tr An exception to log
         */
        public static int w(String tag, String msg, Throwable tr) {
            return println(LOG_ID_MAIN, WARN, tag, msg + '\n' + getStackTraceString(tr));
        }

        /*
         * Send a {@link #WARN} log message and log the exception.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param tr An exception to log
         */
        public static int w(String tag, Throwable tr) {
            return println(LOG_ID_MAIN, WARN, tag, getStackTraceString(tr));
        }

        /**
         * Send an {@link #ERROR} log message.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         */
        public static int e(String tag, String msg) {
            return println(LOG_ID_MAIN, ERROR, tag, msg);
        }

        /**
         * Send a {@link #ERROR} log message and log the exception.
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         * @param tr An exception to log
         */
        public static int e(String tag, String msg, Throwable tr) {
            return println(LOG_ID_MAIN, ERROR, tag, msg + '\n' + getStackTraceString(tr));
        }

        /**
         * Handy function to get a loggable stack trace from a Throwable
         * @param tr An exception to log
         */
        public static String getStackTraceString(Throwable tr) {
            if (tr == null) {
                return "";
            }

            // This is to reduce the amount of log spew that apps do in the non-error
            // condition of the network being unavailable.
            Throwable t = tr;
            while (t != null) {
                if (t instanceof UnknownHostException) {
                    return "";
                }
                t = t.getCause();
            }

            StringWriter sw = new StringWriter();
            PrintWriter pw = new PrintWriter(sw);
            tr.printStackTrace(pw);
            pw.flush();
            return sw.toString();
        }

        /**
         * Low-level logging call.
         * @param priority The priority/type of this log message
         * @param tag Used to identify the source of a log message.  It usually identifies
         *        the class or activity where the log call occurs.
         * @param msg The message you would like logged.
         * @return The number of bytes written.
         */
        public static int println(int priority, String tag, String msg) {
            return println(LOG_ID_MAIN, priority, tag, msg);
        }

        /** @hide */ public static final int LOG_ID_MAIN = 0;
        /** @hide */ public static final int LOG_ID_RADIO = 1;
        /** @hide */ public static final int LOG_ID_EVENTS = 2;
        /** @hide */ public static final int LOG_ID_SYSTEM = 3;
        /** @hide */ public static final int LOG_ID_CRASH = 4;

        /** @hide */ @SuppressWarnings("unused")
        public static int println(int bufID,
                int priority, String tag, String msg) {
            return 0;
        }
    }
阅读更多
发表Android7 分钟读完 (大约1042个字)

Android version 的作用

1.CompileSdkVersion的作用

  • compileSdkVersion 告诉 Gradle 用哪个 Android SDK 版本编译你的应用。使用任何新添加的 API 就需要使用对应 Level 的 Android SDK。
  • 需要强调的是修改 compileSdkVersion 不会改变运行时的行为。当你修改了 compileSdkVersion 的时候，可能会出现新的编译警告、编译错误，但新的 compileSdkVersion 不会被包含到 APK 中：它纯粹只是在编译的时候使用。（你真的应该修复这些警告，他们的出现一定是有原因的）
阅读更多
发表Android27 分钟读完 (大约4019个字)

Android Fragment 源码分析

一 Fragment操作方法

Fragment的操作是一种事务操作，什么是事务？🤔简单来说就是一个原子操作，要么被成功执行，否则原来的操作会回滚，各个操作彼此之间互不干扰。我们先整体看下Fragment的操作
序列图。

fragment_operation_sequence

阅读更多
发表Android10 分钟读完 (大约1438个字)

Android 代码混淆

01.什么是混淆

  • 混淆代码
    • 混淆分为两种代码混淆和资源文件混淆。实际的产品研发中为了防止自己的劳动成果被别人窃取，混淆代码能有效防止apk文件被反编译，进而查看源代码。
  • Android如何混淆
    • android提供了Progurd方式来混淆apk中的代码，其核心的逻辑是在代码层将一些易懂的源代码类名，方法名称替换成毫无意义的a、b、c、d…，这样当第三方反编译出你的Apk文件时，看到的源代码也无法还原其本身的逻辑，或者代码中方法，类，对象等变成无法阅读的字母。
阅读更多
关注我

链接

归档

标签

CentOS2
Docker1
Dubbo7
JDBC1
JPMS1
JVM3
Kafka1
LLM1
MySQL1
Nacos21
Seata13
Sentinel18
Spring Cloud39
Spring Cloud Alibaba66
Spring Cloud Gateway6
Stable Diffusion2
TCP/IP1
ZooKeeper19
gcc1
modules1
mysql1
nginx1
nio1
分布式10
分布式事务14
加密1
基础672
多线程1
安全2
应用层1
数据库2
数据结构与算法36
方案1
源码解析18
知识点22
缓存1
网络1
设计模式25
语法1
调优2
集合4
面试题2

最新文章

分类

×