Android Framework 启动流程简单解析~

分类：Android作者：码中之牛

对于Android开发，干上几年后，都要进阶，或者直接转行了。如果你还在干Android，想要进阶 对Framework的了解是必不可少的过程，下面就开始进入今天的主题吧。

我们知道，对于任何程序语言而言，入口一般都是main函数。

那Android的程序入口在哪呢？ 他的main函数是怎么启动起来的呢？

可能熟悉Android的朋友，知道一个应用程序的入口在ActivityThread中，那有个问题，ActivityThread中的main函数是何时被谁被调用的呢？

将从本文中找到以上答案，如果已经熟悉了此过程的朋友，可以在温习一下。

Android架构

Android 平台的基础是 Linux 内核。Android Runtime (ART/Dalvik) 依靠 Linux 内核来执行底层功能，例如线程和低层内存管理等。

而在Android Runtime之上就是我们经常接触的Java API Framework层， 如下图是Android的系统架构图

今天的主题不是此架构图的各个部分解释，而是离应用层更近的Framework层启动过程分析。

Android Framework概述

如果我们这里抛开Android架构图，那狭义的Framewrok主要包含那些内容呢？

按我的理解，可以分为三个部分 服务端，客户端，和依赖Linux底层能力的驱动部分。

服务端

主要是ActivityManagerService（AMS）， WindowManagerService（WMS），PackageM anerService（PMS）

  • AMS 主要用于管理所有应用程序的Activity
  • WMS 管理各个窗口，隐藏，显示等
  • PMS 用来管理跟踪所有应用APK，安装，解析，控制权限等.

还有用来处理触摸消息的两个类KeyInputQueue和InputDispatchThread，一个用来读消息，一个用来分发消息.

客户端

主要包括ActivityThread，Activity，DecodeView及父类View，PhoneWindow，ViewRootImpl及内部类W等

  • ActivityThread主要用来和AMS通讯的客户端，Activity是我们编写应用比较熟悉的类
  • 后面几个类的介绍，可以参考我的另一篇博客 Android 绘制原理浅析【干货】

依赖Linux底层能力的驱动

主要是SurfaceFlingger（SF）和Binder驱动

  • 每一个窗口都对应一个Surface，SF驱动的作用就是把每一个Surface显示到同一个屏幕上
  • Binder 内核驱动的作用，就是为上面的服务端和客户端(或者服务端和服务端之间)，提供IPC通讯用的。

Zygote

系统中运行的第一个Dalvik虚拟机程序叫做zygote，该名称的意义是“一个卵”，，因为接下来的所有 Dalvik虚拟机进程都是通过这个“卵” 孵化出来的。

zygote进程中包含两个主要模块，分别如下：

  • Socket服务端。该 Socket服务端用于接收启动新的Dalvik进程的命令。
  • Framework共享类及共享资源。当zygote进程启动后，会装载一些共享的类及资源，其中共享类是在preload-classes文件中被定义，共享资源是在preload-resources中被定义。因为zygote进程用于孵化出其他Dalvik进程，因此，这些类和资源装载后，新的Dalvik进程就不需要再装载这些类和资源了，这也就是所谓的共享。

zygote进程对应的具体程序是app_rocess,该程序存在于system/bin目录下，启动该程序的指令是 在 init.rc中进行配置的。

Zygote 有️两个优秀的特点

  • 每fork出的一个进程都是一个Dalvik虚拟机，独立的进程可以防止一个程序的崩溃导致所有程序都崩溃，这种虚拟机类似Java虚拟机，对于程序员来说，可以直接使用Java开发应用
  • zygote进程预先会装载共享类和共享资源，这些类及资源实际上就是SDK中定义的大部分类和资源。因此，当通过zygote孵化出新的进程后，新的APK进程只需要去装载A PK 自身包含的类和资源即可，这就有效地解决了多个APK共享Framework资源的问题。

SystemServer

zygote孵化出的第一个Dalvik进程叫做SystemServer，SystemServer仅仅是该进程的别名，而该进程具体对应的程序依然是app_process，因为SystemServer是从app_process中孵化出来的。

SystemServer中创建了一个Socket客户端，并有AmS负责管理该客户端，之后所有的Dalvik进程都将通过该Socket客户端间接被启动。当需要启动新的APK进程时，AmS中会通过该Socket客户端向 zygote进程的Socket服务端发送一个启动命令，然 后 zygote会孵化出新的进程。 上面提到的服务端，AMS，PMS，WMS等都是在SystemServer中启动的.

Android Framework 源头

操作系统的一般启动流程，分为三个步骤

  1. 开机通电后，加载bootloader程序
  2. 操作系统内核初始化
  3. 执行第一个应用程序

Android 系统是基于Linux 内核Kernel，前面Linux bootloader这里不做介绍，直接介绍操作系统内核初始化，在这个时候，它会加载init.rc文件.

init.rc文件

在Android根目录下面，可以直接找到init.rc

generic_x86:/ # ls
acct     bin        cache   config data         dev init            init.rc              init.usb.rc      lost+found mnt oem  product sdcard  sys    ueventd.rc 
adb_keys bugreports charger d      default.prop etc init.environ.rc init.usb.configfs.rc init.zygote32.rc metadata   odm proc sbin    storage system vendor

打开init.rc

generic_x86:/ # cat init.rc
# ..... 省略其他
 # Now we can start zygote for devices with file based encryption
trigger zygote-start

# It is recommended to put unnecessary data/ initialization from post-fs-data
# to start-zygote in device's init.rc to unblock zygote start.
on zygote-start 
    # A/B update verifier that marks a successful boot.
    exec_start update_verifier_nonencrypted
    start netd
    start zygote
    start zygote_secondary

on property:vold.decrypt=trigger_restart_framework
    stop surfaceflinger
# 启动SF
    start surfaceflinger  
    
# ..... 省略其他 media(媒体)  network（网络）等启动

也就是在 init.rc时，启动Android 内核。

app_process

Android 内核也是main方法开始，他的main方法在 frameworks/base/cmds/app_process/app_main.cpp下

int main(int argc,char* const argv[])
{
    ...
    //初始化AndroidRuntime
    AppRuntime runtime(argv[0],computeArgBlockSize(argc,argv));
    
    bool zygote = false;
    bool startSystemServer = false;
    bool application = false;
    String8 niceName;
    String8 className;

    // 根据参数具体判断启动那个服务
    ++i;  // Skip unused "parent dir" argument.
    while (i < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg,"--zygote") == 0) {
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
        } else if (strcmp(arg,"--start-system-server") == 0) {
            startSystemServer = true;
        } else if (strcmp(arg,"--application") == 0) {
            application = true;
        } else if (strncmp(arg,"--nice-name=",12) == 0) {
            niceName.setTo(arg + 12);
        } else if (strncmp(arg,"--",2) != 0) {
            className.setTo(arg);
            break;
        } else {
            --i;
            break;
        }
    }
    if (!className.isEmpty()) {
        args.add(application ? String8("application") : String8("tool"));
        runtime.setClassNameAndArgs(className,argc - i,argv + i);
    }else{
        ....
        //启动SystemServer
        if (startSystemServer) {
            args.add(String8("start-system-server"));
        }
    }
    ....
     if (zygote) {
       //启动Zygote
        runtime.start("com.android.internal.os.ZygoteInit",args,zygote);
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit",zygote);
    } else {
        fprintf(stderr,"Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

在这个Main方法中，先初始化了AppRuntime，他的父类是AndroidRuntime。然后我们看到了启动了Java类ZygoteInit。

那c++代码里怎么启动Java类呢，我们继续看 start方法

void AndroidRuntime::start(const char* className,const Vector<String8>& options,bool zygote)
{
   ...
   //启动Java虚拟机
     if (startVm(&mJavaVM,&env,zygote,primary_zygote) != 0) {
        return;
    }
    ...
    //找到Java 里面的Main方法
     jmethodID startMeth = env->GetStaticMethodID(startClass,"main","([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n",className);
            /* keep going */
        } else {
        //执行Main方法
            env->CallStaticVoidMethod(startClass,startMeth,strArray);
    }
    ....    
}

可以看到最后先创建了Java虚拟机，调用了Java的main方法，是不是感觉有些熟悉感了。

ZygoteInit

上面介绍到，会启动Java的ZygoteInit类，那他里面干了些什么呢？ 我们来看一下关键代码，还是从Main方法开始

//ZygoteInit.java
  public static void main(String argv[]) {
    ZygoteServer zygoteServer = new ZygoteServer();
    ZygoteHooks.startZygoteNoThreadCreation();

    //创建socket
    zygoteServer.createZygoteSocket(socketName);
    Zygote.createBlastulaSocket(blastulaSocketName);

    if (!enableLazyPreload) {
            bootTimingsTraceLog.traceBegin("ZygotePreload");
            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,SystemClock.uptimeMillis());
            //预加载系统资源
            preload(bootTimingsTraceLog);
            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,SystemClock.uptimeMillis());
            bootTimingsTraceLog.traceEnd(); // ZygotePreload
    } else {
        Zygote.resetNicePriority();
    }

    //fork SystemServer进程
    if (startSystemServer) {
        Runnable r = forkSystemServer(abiList,socketName,zygoteServer);
        // child (system_server) process.
        if (r != null) {
            r.run();
            return;
        }
    }

    //等待Socket的接入
    if (caller == null) {
        Log.i(TAG,"Accepting command socket connections");
        // The select loop returns early in the child process after a fork and
        // loops forever in the zygote.
        caller = zygoteServer.runSelectLoop(abiList);
    }

注释写了大概Zygote 启动里面的初始化内容

  • 创建Socket
  • 加载系统资源
  • 启动SystemServer
  • runSelectLoop 等待socket接入，开始执行fork新的进程.

SystemServer

下面继续看SystemServer 启动的过程，从Main方法开始

//SystemServer.java
   /**
     * The main entry point from zygote.
     */
    public static void main(String[] args) {
        new SystemServer().run();
    }

很简单，创建一个自己的对象，并执行run方法,看一下run方法

private void run() {
    ...
    if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
        Slog.w(TAG,"System clock is before 1970; setting to 1970.");
        SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
    }

    VMRuntime.getRuntime().clearGrowthLimit();
    // The system server has to run all of the time,so it needs to be
    // as efficient as possible with its memory usage.
    VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);

    android.os.Process.setThreadPriority(
                android.os.Process.THREAD_PRIORITY_FOREGROUND);
    android.os.Process.setCanSelfBackground(false);
    Looper.prepareMainLooper();

   // Create the system service manager.
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    mSystemServiceManager.setStartInfo(mRuntimeRestart,mRuntimeStartElapsedTime,mRuntimeStartUptime);
    LocalServices.addService(SystemServiceManager.class,mSystemServiceManager);

   try {
        traceBeginAndSlog("StartServices");
        startBootstrapServices();
        startCoreServices();
        startOtherServices();
        SystemServerInitThreadPool.shutdown();
    } catch (Throwable ex) {
           Slog.e("System","******************************************");
            Slog.e("System","************ Failure starting system services",ex);
            throw ex;
    } finally {
        traceEnd();
    }

    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");
}

run方法里面主要进行了设置手机时间，设置虚拟机内存大小，创建消息循环Looper,创建SystemServiceManager等，最主要的是启动了各类服务，我们接着看一下startBootstrapServices ，startCoreServices，startOtherServices方法

private void startBootstrapServices() {
    Installer installer = mSystemServiceManager.startService(Installer.class);
    mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);

    mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    ....
}

private void startCoreServices() {
    ...
     mSystemServiceManager.startService(BatteryService.class);
     ...
}

 private void startOtherServices() {
        final Context context = mSystemContext;
        VibratorService vibrator = null;
        DynamicAndroidService dynamicAndroid = null;
        IStorageManager storageManager = null;
        NetworkManagementService networkManagement = null;
        IpSecService ipSecService = null;
        NetworkStatsService networkStats = null;
        NetworkPolicyManagerService networkPolicy = null;
        ConnectivityService connectivity = null;
        NsdService serviceDiscovery= null;
        WindowManagerService wm = null;
        SerialService serial = null;
        NetworkTimeUpdateService networkTimeUpdater = null;
        InputManagerService inputManager = null;
        TelephonyRegistry telephonyRegistry = null;
        ConsumerIrService consumerIr = null;
        MmsServiceBroker mmsService = null;
        HardwarePropertiesManagerService hardwarePropertiesService = null;
        ....
}

在这些方法中启动了，我们的核心服务，和常用服务。 代码中也可以看到AMS，PMS，WMS等相关服务.

Launcher启动介绍

一般服务启动完成后，就会想继调用systemReady()方法。 在SysytemServer startOtherServices中看到一个监听回调

mActivityManagerService.systemReady(() -> {
  try {
        startSystemUi(context,windowManagerF);
    } catch (Throwable e) {
        reportWtf("starting System UI",e);
    }
  }
}

static final void startSystemUi(Context context,WindowManagerService windowManager) {
        Intent intent = new Intent();
        intent.setComponent(new ComponentName("com.android.systemui","com.android.systemui.SystemUIService"));
        intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
        //Slog.d(TAG,"Starting service: " + intent);
        context.startServiceAsUser(intent,UserHandle.SYSTEM);
        windowManager.onSystemUiStarted();
}

而Ams启动完成后，显示Launcher

//AMS.java
 public void systemReady(final Runnable goingCallback,TimingsTraceLog traceLog) {
 ...
     startHomeActivityLocked(currentUserId,"systemReady");
     //
     mStackSupervisor.resumeFocusedStackTopActivityLocked();
 ...
 }

其实到这里大致流程就介绍完了，但是文章开始的ActivityThread的main方法是何时被调用的，还没回答，这里不详细展开，简略回答一些.

ActivityThread的main方法如何被调用的？

AMS是管理Activity的启动结束等，查看AMS代码，当当前启动的APP没有创建进程时，会最终调用到ZygoteProcess，然后向 Zygote发送一个socket请求。

resumeTopActivityLocked -> startProcessLocked -> Process.start() -> ZygoteProcess.start() -> ZygoteProcess.startViaZygote() —> ZygoteProcess.zygoteSendArgsAndGetResult()

接下来，看一下大致代码

//AMS.java
private final boolean startProcessLocked(ProcessRecord app,String hostingType,String hostingNameStr,boolean disableHiddenApiChecks,String abiOverride) {
            //这里entryPoint为ActivityThread
     final String entryPoint = "android.app.ActivityThread";

    return startProcessLocked(hostingType,hostingNameStr,entryPoint,app,uid,gids,runtimeFlags,mountExternal,seInfo,requiredAbi,instructionSet,invokeWith,startTime);    
}

//ZygoteProcess.java
private Process.ProcessStartResult startViaZygote(final String processClass,... ){
    ArrayList<String> argsForZygote = new ArrayList<String>();
    argsForZygote.add("--runtime-args");
    argsForZygote.add("--setuid=" + uid);
    argsForZygote.add("--setgid=" + gid);
    argsForZygote.add("--runtime-flags=" + runtimeFlags);
    argsForZygote.add("--target-sdk-version=" + targetSdkVersion);
    if (startChildZygote) {
        argsForZygote.add("--start-child-zygote");
    }
    argsForZygote.add(processClass);
    synchronized(mLock) {
        return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),useBlastulaPool,argsForZygote);
    }
}

//发起Socket请求，给Zygote
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
        ArrayList<String> args,..){
    blastulaSessionSocket = zygoteState.getBlastulaSessionSocket();

    final BufferedWriter blastulaWriter = new BufferedWriter(
            new OutputStreamWriter(blastulaSessionSocket.getOutputStream()),Zygote.SOCKET_BUFFER_SIZE);
    final DataInputStream blastulaReader =
    new DataInputStream(blastulaSessionSocket.getInputStream());
    blastulaWriter.write(msgStr);
    blastulaWriter.flush();
    ...
}

最终 Zygote收到请求调用ZygoteInit中zygoteinit方法

//ZygoteInit.java
 public static final Runnable zygoteInit(int targetSdkVersion,String[] argv,ClassLoader classLoader) {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG,"RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,"ZygoteInit");
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
        ZygoteInit.nativeZygoteInit();
        return RuntimeInit.applicationInit(targetSdkVersion,argv,classLoader);
    }

在 RuntimeInit中findStaticMain，最后在ZygoteInit中执行最终返回的这个Runnable,达到调用main方法的目的.

protected static Runnable applicationInit(int targetSdkVersion,ClassLoader classLoader) {
        nativeSetExitWithoutCleanup(true);
        VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
        VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
        final Arguments args = new Arguments(argv);
        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
        return findStaticMain(args.startClass,args.startArgs,classLoader);
    }

protected static Runnable findStaticMain(String className,ClassLoader classLoader) {
        ..
        m = cl.getMethod("main",new Class[] { String[].class });
        return new MethodAndArgsCaller(m,argv);
    }

总结

如果你都看到这了，希望帮忙点个赞，谢谢啦。 因为本人水平有限，各路大佬如看到文中有错误，欢迎指出，在此表示感谢。

最后为了帮助到大家有效率的学好 Android Framework知识点，特意整理了一份Framework的开发进阶滋尿，帮助大家在技术的道路上更进一步，大家有需要的可以私信回复 666 即可

原文地址：https://blog.csdn.net/weixin_61845324

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

更新Android SDK到3.0版本时，遇到Failed to rename directory E:androidtools to E:androidtempToolPackage.old01问题
更新Android SDK到3.0版本时，遇到Failed to rename directory E:\android\tools to E:\android\temp\ToolPackage.old01问题，导致无法更新，出现该问题的原因是由于3.0版本与较早的sdk版本之间文件结构有冲突，解决
Android 如何解决dialog弹出时无法捕捉Activity的back事件
Android 如何解决dialog弹出时无法捕捉Activity的back事件 在一些情况下，我们需要捕捉back键事件，然后在捕捉到的事件里写入我们需要进行的处理，通常可以采用下面三种办法捕捉到back事件： 1）重写onKeyDown或者onKeyUp方法 2）重写onBackPressed方
Android实现自定义带文字和图片的Button
Android实现自定义带文字和图片的Button 在Android开发中经常会需要用到带文字和图片的button，下面来讲解一下常用的实现办法。一.用系统自带的Button实现 最简单的一种办法就是利用系统自带的Button来实现，这种方式代码量最小。在Button的属性中有一个是drawable
Android中的"Unable to start activity ComponentInfo"或者"Unable to instantiate activity ComponentInfo"的错误
Android中的&quot;Unable to start activity ComponentInfo&quot;的错误 最近在做一款音乐播放器的时候，然后在调试的过程中发现一直报这个错误&quot;Unable to start activity ComponentInfo&quot;，从字面
Android 关于长按back键退出应用程序的实现
Android 关于长按back键退出应用程序的实现最近在做一个Android上的应用，碰到一个问题就是如何实现长按back键退出应用程序。在网上查找了很多资料，发现几乎没有这样的实现，大部分在处理时是双击back键来退出应用程序。参考了一下双击back键退出应用程序的代码，网上主流的一种方法是下面
android 可以精确到秒级的时间选择器
android自带的时间选择器只能精确到分，但是对于某些应用要求选择的时间精确到秒级，此时只有自定义去实现这样的时间选择器了。下面介绍一个可以精确到秒级的时间选择器。 先上效果图： 下面是工程目录： 这个控件我也是用的别人的，好像是一个老外写的，com.wheel中的WheelView是滑动控件的主
Android平台下利用zxing实现二维码开发
Android平台下利用zxing实现二维码开发 现在走在大街小巷都能看到二维码，而且最近由于项目需要，所以研究了下二维码开发的东西，开源的二维码扫描库主要有zxing和zbar，zbar在iPos平台上应用比较成熟，而在Android平台上主流还是用zxing库，因此这里主要讲述如何利用zxing
Android ListView的item背景色设置以及item点击无响应等相关问题
Android ListView的item背景色设置以及item点击无响应等相关问题 在Android开发中，listview控件是非常常用的控件，在大多数情况下，大家都会改掉listview的item默认的外观，下面讲解以下在使用listview时最常见的几个问题。1.如何改变item的背景色和按
如何向Android模拟器中导入含有中文名称的文件
如何向Android模拟器中导入含有中文名称的文件在进行Android开发的时候，如果需要向Android模拟器中导入文件进行测试，通过DDMS下手动导入或者在命令行下通过adb push命令是无法导入含有中文文件名的文件的。后来发现借用其他工具可以向模拟器中导入中文名称的文件，这个工具就是Ultr
Windows 下搭建Android开发环境
Windows 下搭建Android开发环境一．下载并安装JDK版本要求JDK1.6+，下载JDK成功后进行安装，安装好后进行环境变量的配置【我的电脑】-——&gt;【属性】——&gt;【高级】 ——&gt;【环境变量】——&gt;【系统变量】中点击【新建】：变量名：CLASSPATH变量值：……
如何利用PopupWindow实现弹出菜单并解决焦点获取以及与软键盘冲突问题
如何利用PopupWindow实现弹出菜单并解决焦点获取以及与软键盘冲突问题 在android中有时候可能要实现一个底部弹出菜单，此时可以考虑用PopupWindow来实现。下面就来介绍一下如何使用PopupWindow实现一个弹出窗。 主Activity代码：public void onCreat
解决Android中的ERROR: the user data image is used by another emulator. aborting的方法
解决Android中的ERROR: the user data image is used by another emulator. aborting的方法 今天调试代码的时候，突然出现这个错误，折腾了很久没有解决。最后在google上找到了大家给出的两种解决方案，下面给出这两种方法的链接博客：ht
ViewFlipper 简单应用
AdvserView.java package com.earen.viewflipper; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory;
ImageView的scaleType属性 与 adjustViewBounds属性
ImageView的scaleType的属性有好几种，分别是matrix（默认）、center、centerCrop、centerInside、fitCenter、fitEnd、fitStart、fitXY。 |值|说明| |:--:|:--| |center|保持原图的大小，显示在ImageVie
在Android studio 3.2 版项目中使用cmake调用C/C++
文章浏览阅读8.8k次，点赞9次，收藏20次。本文操作环境:win10/Android studio 3.21.环境配置 在SDK Tools里选择 CMAKE/LLDB/NDK点击OK 安装这些插件. 2.创建CMakeLists.txt文件 在Project 目录下,右键app，点击新建File文件,命名为CMakeLists.txt点击OK，创建完毕! 3.配置文件 在CMa..._link c++ project with gradle
Android studio跳转界面
文章浏览阅读1.2w次，点赞15次，收藏69次。实现目的：由mainActivity界面跳转到otherActivity界面1.写好两个layout文件，activity_main.xml和otherxml.xmlactivity_main.xml&lt;?xml version="1.0" encoding="utf-8"?&gt;&lt;RelativeLayout ="http://schemas..._android studio 界面跳转
Android全局代理软件ProxyDroid和TransProxy源码分享
文章浏览阅读3.8w次。前言：最近在找Android上的全局代理软件来用，然后发现了这两款神作，都是外国的软件，而且都是开源的软件，因此把源码下载了下来，给有需要研究代理这方面的童鞋看看。不得不说，国外的开源精神十分浓，大家相互使用当前基础的开源软件，然后组合成一个更大更强的大开源软件。好吧，废话不多说，下面简单介绍一下这两款开源项目。一、ProxyDroid：ProxyDroid功能比较强大，用到的技术也比较多，源码也_proxydroid
Error:(23, 25) 错误: 程序包R不存在
文章浏览阅读2.5w次，点赞17次，收藏6次。创建项目后，运行项目时Gradle Build 窗口却显示错误：程序包R不存在通常情况下是不会出现这个错误的。我是怎么遇到这个错误的呢？第一次创建项目，company Domain我使用的是：aven.com，但是创建过程在卡在了Building 'Calculator' Gradle Project info这个过程中，于是我选择了“Cancel”第二次创建项目，我还是使用相同的项目名称和项目路_r不存在
教你在Android手机上使用全局代理！
文章浏览阅读8.9w次，点赞4次，收藏43次。前言：在Android上使用系统自带的代理，限制灰常大，仅支持系统自带的浏览器。这样像QQ、飞信、微博等这些单独的App都不能使用系统的代理。如何让所有软件都能正常代理呢？ProxyDroid这个软件能帮你解决！使用方法及步骤如下：一、推荐从Google Play下载ProxyDroid，目前最新版本是v2.6.6。二、对ProxyDroid进行配置（基本配置：） （1） Auto S_proxydroid使用教程
【Android 开发入门】Android设备监视器之调试工具DDMS使用初探
文章浏览阅读1.1w次，点赞4次，收藏17次。Android Studio提供了一个很实用的工具Android设备监视器(Android device monitor)，该监视器中最常用的一个工具就是DDMS（Dalvik Debug Monitor Service），是 Android 开发环境中的Dalvik虚拟机调试监控服务。可以进行的操作有：为测试设备截屏，查看特定进程中正在运行的线程以及堆栈信息、Logcat、广播状态信息、模拟电话_安卓摄像头调试工具
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot