AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android应用程序启动过程源代码分析（1）

2017-11-15 862
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

      前文简要介绍了Android应用程序的Activity的启动过程。在Android系统中，应用程序是由Activity组成的，因此，应用程序的启动过程实际上就是应用程序中的默认Activity的启动过程，本文将详细分析应用程序框架层的源代码，了解Android应用程序的启动过程。

        在上一篇文章Android应用程序的Activity启动过程简要介绍和学习计划中，我们举例子说明了启动Android应用程序中的Activity的两种情景，其中，在手机屏幕中点击应用程序图标的情景就会引发Android应用程序中的默认Activity的启动，从而把应用程序启动起来。这种启动方式的特点是会启动一个新的进程来加载相应的Activity。这里，我们继续以这个例子为例来说明Android应用程序的启动过程，即MainActivity的启动过程。

        MainActivity的启动过程如下图所示： 

        下面详细分析每一步是如何实现的。

        Step 1. Launcher.startActivitySafely

        在Android系统中，应用程序是由Launcher启动起来的，其实，Launcher本身也是一个应用程序，其它的应用程序安装后，就会Launcher的界面上出现一个相应的图标，点击这个图标时，Launcher就会对应的应用程序启动起来。

        Launcher的源代码工程在packages/apps/Launcher2目录下，负责启动其它应用程序的源代码实现在src/com/android/launcher2/Launcher.java文件中：


  
  
    

   
   
  1. /**  
    2. 

   
   
  2. * Default launcher application.  
    3. 

   
   
  3. */   
    4. 

   
   
  4. public final class Launcher extends Activity   
    5. 

   
   
  5.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {   
    6. 

   
   
  6.    
    7. 

   
   
  7.     ......   
    8. 

   
   
  8.    
    9. 

   
   
  9.     /**  
    10. 

   
   
  10.     * Launches the intent referred by the clicked shortcut.  
    11. 

   
   
  11.     *  
    12. 

   
   
  12.     * @param v The view representing the clicked shortcut.  
    13. 

   
   
  13.     */   
    14. 

   
   
  14.     public void onClick(View v) {   
    15. 

   
   
  15.         Object tag = v.getTag();   
    16. 

   
   
  16.         if (tag instanceof ShortcutInfo) {   
    17. 

   
   
  17.             // Open shortcut   
    18. 

   
   
  18.             final Intent intent = ((ShortcutInfo) tag).intent;   
    19. 

   
   
  19.             int[] pos = new int[2];   
    20. 

   
   
  20.             v.getLocationOnScreen(pos);   
    21. 

   
   
  21.             intent.setSourceBounds(new Rect(pos[0], pos[1],   
    22. 

   
   
  22.                 pos[0] + v.getWidth(), pos[1] + v.getHeight()));   
    23. 

   
   
  23.             startActivitySafely(intent, tag);   
    24. 

   
   
  24.         } else if (tag instanceof FolderInfo) {   
    25. 

   
   
  25.             ......   
    26. 

   
   
  26.         } else if (v == mHandleView) {   
    27. 

   
   
  27.             ......   
    28. 

   
   
  28.         }   
    29. 

   
   
  29.     }   
    30. 

   
   
  30.    
    31. 

   
   
  31.     void startActivitySafely(Intent intent, Object tag) {   
    32. 

   
   
  32.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);   
    33. 

   
   
  33.         try {   
    34. 

   
   
  34.             startActivity(intent);   
    35. 

   
   
  35.         } catch (ActivityNotFoundException e) {   
    36. 

   
   
  36.             ......   
    37. 

   
   
  37.         } catch (SecurityException e) {   
    38. 

   
   
  38.             ......   
    39. 

   
   
  39.         }   
    40. 

   
   
  40.     }   
    41. 

   
   
  41.    
    42. 

   
   
  42.     ......   
    43. 

   
   
  43.    
    44. 

   
   
  44. }   
    45.

        回忆一下前面一篇文章Android应用程序的Activity启动过程简要介绍和学习计划说到的应用程序Activity，它的默认Activity是MainActivity，这里是AndroidManifest.xml文件中配置的：


  
  
    

   
   
  1. <activity android:name=".MainActivity"     
    2. 

   
   
  2.       android:label="@string/app_name">     
    3. 

   
   
  3.        <intent-filter>     
    4. 

   
   
  4.         <action android:name="android.intent.action.MAIN" />     
    5. 

   
   
  5.         <category android:name="android.intent.category.LAUNCHER" />     
    6. 

   
   
  6.     </intent-filter>     
    7. 

   
   
  7. </activity>     
    8.

        因此，这里的intent包含的信息为：action = "android.intent.action.Main"，category="android.intent.category.LAUNCHER", cmp="shy.luo.activity/.MainActivity"，表示它要启动的Activity为shy.luo.activity.MainActivity。Intent.FLAG_ACTIVITY_NEW_TASK表示要在一个新的Task中启动这个Activity，注意，Task是Android系统中的概念，它不同于进程Process的概念。简单地说，一个Task是一系列Activity的集合，这个集合是以堆栈的形式来组织的，遵循后进先出的原则。事实上，Task是一个非常复杂的概念，有兴趣的读者可以到官网http://developer.android.com/guide/topics/manifest/activity-element.html查看相关的资料。这里，我们只要知道，这个MainActivity要在一个新的Task中启动就可以了。

        Step 2. Activity.startActivity

        在Step 1中，我们看到，Launcher继承于Activity类，而Activity类实现了startActivity函数，因此，这里就调用了Activity.startActivity函数，它实现在frameworks/base/core/java/android/app/Activity.java文件中：


  
  
    

   
   
  1. public class Activity extends ContextThemeWrapper   
    2. 

   
   
  2.         implements LayoutInflater.Factory,   
    3. 

   
   
  3.         Window.Callback, KeyEvent.Callback,   
    4. 

   
   
  4.         OnCreateContextMenuListener, ComponentCallbacks {   
    5. 

   
   
  5.    
    6. 

   
   
  6.     ......   
    7. 

   
   
  7.    
    8. 

   
   
  8.     @Override   
    9. 

   
   
  9.     public void startActivity(Intent intent) {   
    10. 

   
   
  10.         startActivityForResult(intent, -1);   
    11. 

   
   
  11.     }   
    12. 

   
   
  12.    
    13. 

   
   
  13.     ......   
    14. 

   
   
  14.    
    15. 

   
   
  15. }   
    16.

        这个函数实现很简单，它调用startActivityForResult来进一步处理，第二个参数传入-1表示不需要这个Actvity结束后的返回结果。

        Step 3. Activity.startActivityForResult

        这个函数也是实现在frameworks/base/core/java/android/app/Activity.java文件中：


  
  
    

   
   
  1. public class Activity extends ContextThemeWrapper   
    2. 

   
   
  2.         implements LayoutInflater.Factory,   
    3. 

   
   
  3.         Window.Callback, KeyEvent.Callback,   
    4. 

   
   
  4.         OnCreateContextMenuListener, ComponentCallbacks {   
    5. 

   
   
  5.    
    6. 

   
   
  6.     ......   
    7. 

   
   
  7.    
    8. 

   
   
  8.     public void startActivityForResult(Intent intent, int requestCode) {   
    9. 

   
   
  9.         if (mParent == null) {   
    10. 

   
   
  10.             Instrumentation.ActivityResult ar =   
    11. 

   
   
  11.                 mInstrumentation.execStartActivity(   
    12. 

   
   
  12.                 this, mMainThread.getApplicationThread(), mToken, this,   
    13. 

   
   
  13.                 intent, requestCode);   
    14. 

   
   
  14.             ......   
    15. 

   
   
  15.         } else {   
    16. 

   
   
  16.             ......   
    17. 

   
   
  17.         }   
    18. 

   
   
  18.    
    19. 

   
   
  19.    
    20. 

   
   
  20.     ......   
    21. 

   
   
  21.    
    22. 

   
   
  22. }   
    23.

         这里的mInstrumentation是Activity类的成员变量，它的类型是Intrumentation，定义在frameworks/base/core/java/android/app/Instrumentation.java文件中，它用来监控应用程序和系统的交互。

         这里的mMainThread也是Activity类的成员变量，它的类型是ActivityThread，它代表的是应用程序的主线程，我们在Android系统在新进程中启动自定义服务过程（startService）的原理分析一文中已经介绍过了。这里通过mMainThread.getApplicationThread获得它里面的ApplicationThread成员变量，它是一个Binder对象，后面我们会看到，ActivityManagerService会使用它来和ActivityThread来进行进程间通信。这里我们需注意的是，这里的mMainThread代表的是Launcher应用程序运行的进程。

         这里的mToken也是Activity类的成员变量，它是一个Binder对象的远程接口。

         Step 4. Instrumentation.execStartActivity
         这个函数定义在frameworks/base/core/java/android/app/Instrumentation.java文件中：


  
  
    

   
   
  1. public class Instrumentation {   
    2. 

   
   
  2.    
    3. 

   
   
  3.     ......   
    4. 

   
   
  4.    
    5. 

   
   
  5.     public ActivityResult execStartActivity(   
    6. 

   
   
  6.     Context who, IBinder contextThread, IBinder token, Activity target,   
    7. 

   
   
  7.     Intent intent, int requestCode) {   
    8. 

   
   
  8.         IApplicationThread whoThread = (IApplicationThread) contextThread;   
    9. 

   
   
  9.         if (mActivityMonitors != null) {   
    10. 

   
   
  10.             ......   
    11. 

   
   
  11.         }   
    12. 

   
   
  12.         try {   
    13. 

   
   
  13.             int result = ActivityManagerNative.getDefault()   
    14. 

   
   
  14.                 .startActivity(whoThread, intent,   
    15. 

   
   
  15.                 intent.resolveTypeIfNeeded(who.getContentResolver()),   
    16. 

   
   
  16.                 null, 0, token, target != null ? target.mEmbeddedID : null,   
    17. 

   
   
  17.                 requestCode, false, false);   
    18. 

   
   
  18.             ......   
    19. 

   
   
  19.         } catch (RemoteException e) {   
    20. 

   
   
  20.         }   
    21. 

   
   
  21.         return null;   
    22. 

   
   
  22.     }   
    23. 

   
   
  23.    
    24. 

   
   
  24.     ......   
    25. 

   
   
  25.    
    26. 

   
   
  26. }   
    27.

         这里的ActivityManagerNative.getDefault返回ActivityManagerService的远程接口，即ActivityManagerProxy接口，具体可以参考Android系统在新进程中启动自定义服务过程（startService）的原理分析一文。

         这里的intent.resolveTypeIfNeeded返回这个intent的MIME类型，在这个例子中，没有AndroidManifest.xml设置MainActivity的MIME类型，因此，这里返回null。

         这里的target不为null，但是target.mEmbddedID为null，我们不用关注。

         Step 5. ActivityManagerProxy.startActivity

         这个函数定义在frameworks/base/core/java/android/app/ActivityManagerNative.java文件中：


  
  
    

   
   
  1. class ActivityManagerProxy implements IActivityManager   
    2. 

   
   
  2. {   
    3. 

   
   
  3.    
    4. 

   
   
  4.     ......   
    5. 

   
   
  5.    
    6. 

   
   
  6.     public int startActivity(IApplicationThread caller, Intent intent,   
    7. 

   
   
  7.             String resolvedType, Uri[] grantedUriPermissions, int grantedMode,   
    8. 

   
   
  8.             IBinder resultTo, String resultWho,   
    9. 

   
   
  9.             int requestCode, boolean onlyIfNeeded,   
    10. 

   
   
  10.             boolean debug) throws RemoteException {   
    11. 

   
   
  11.         Parcel data = Parcel.obtain();   
    12. 

   
   
  12.         Parcel reply = Parcel.obtain();   
    13. 

   
   
  13.         data.writeInterfaceToken(IActivityManager.descriptor);   
    14. 

   
   
  14.         data.writeStrongBinder(caller != null ? caller.asBinder() : null);   
    15. 

   
   
  15.         intent.writeToParcel(data, 0);   
    16. 

   
   
  16.         data.writeString(resolvedType);   
    17. 

   
   
  17.         data.writeTypedArray(grantedUriPermissions, 0);   
    18. 

   
   
  18.         data.writeInt(grantedMode);   
    19. 

   
   
  19.         data.writeStrongBinder(resultTo);   
    20. 

   
   
  20.         data.writeString(resultWho);   
    21. 

   
   
  21.         data.writeInt(requestCode);   
    22. 

   
   
  22.         data.writeInt(onlyIfNeeded ? 1 : 0);   
    23. 

   
   
  23.         data.writeInt(debug ? 1 : 0);   
    24. 

   
   
  24.         mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);   
    25. 

   
   
  25.         reply.readException();   
    26. 

   
   
  26.         int result = reply.readInt();   
    27. 

   
   
  27.         reply.recycle();   
    28. 

   
   
  28.         data.recycle();   
    29. 

   
   
  29.         return result;   
    30. 

   
   
  30.     }   
    31. 

   
   
  31.    
    32. 

   
   
  32.     ......   
    33. 

   
   
  33.    
    34. 

   
   
  34. }   
    35.

        这里的参数比较多，我们先整理一下。从上面的调用可以知道，这里的参数resolvedType、grantedUriPermissions和resultWho均为null；参数caller为ApplicationThread类型的Binder实体；参数resultTo为一个Binder实体的远程接口，我们先不关注它；参数grantedMode为0，我们也先不关注它；参数requestCode为-1；参数onlyIfNeeded和debug均空false。

        Step 6. ActivityManagerService.startActivity

        上一步Step 5通过Binder驱动程序就进入到ActivityManagerService的startActivity函数来了，它定义在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java文件中：


  
  
    

   
   
  1. public final class ActivityManagerService extends ActivityManagerNative   
    2. 

   
   
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {   
    3. 

   
   
  3.    
    4. 

   
   
  4.     ......   
    5. 

   
   
  5.    
    6. 

   
   
  6.     public final int startActivity(IApplicationThread caller,   
    7. 

   
   
  7.             Intent intent, String resolvedType, Uri[] grantedUriPermissions,   
    8. 

   
   
  8.             int grantedMode, IBinder resultTo,   
    9. 

   
   
  9.             String resultWho, int requestCode, boolean onlyIfNeeded,   
    10. 

   
   
  10.             boolean debug) {   
    11. 

   
   
  11.         return mMainStack.startActivityMayWait(caller, intent, resolvedType,   
    12. 

   
   
  12.             grantedUriPermissions, grantedMode, resultTo, resultWho,   
    13. 

   
   
  13.             requestCode, onlyIfNeeded, debug, null, null);   
    14. 

   
   
  14.     }   
    15. 

   
   
  15.    
    16. 

   
   
  16.    
    17. 

   
   
  17.     ......   
    18. 

   
   
  18.    
    19. 

   
   
  19. }   
    20.

        这里只是简单地将操作转发给成员变量mMainStack的startActivityMayWait函数，这里的mMainStack的类型为ActivityStack。

        Step 7. ActivityStack.startActivityMayWait

        这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：


  
  
    

   
   
  1. public class ActivityStack {   
    2. 

   
   
  2.    
    3. 

   
   
  3.     ......   
    4. 

   
   
  4.    
    5. 

   
   
  5.     final int startActivityMayWait(IApplicationThread caller,   
    6. 

   
   
  6.             Intent intent, String resolvedType, Uri[] grantedUriPermissions,   
    7. 

   
   
  7.             int grantedMode, IBinder resultTo,   
    8. 

   
   
  8.             String resultWho, int requestCode, boolean onlyIfNeeded,   
    9. 

   
   
  9.             boolean debug, WaitResult outResult, Configuration config) {   
    10. 

   
   
  10.    
    11. 

   
   
  11.         ......   
    12. 

   
   
  12.    
    13. 

   
   
  13.         boolean componentSpecified = intent.getComponent() != null;   
    14. 

   
   
  14.    
    15. 

   
   
  15.         // Don't modify the client's object!   
    16. 

   
   
  16.         intent = new Intent(intent);   
    17. 

   
   
  17.    
    18. 

   
   
  18.         // Collect information about the target of the Intent.   
    19. 

   
   
  19.         ActivityInfo aInfo;   
    20. 

   
   
  20.         try {   
    21. 

   
   
  21.             ResolveInfo rInfo =   
    22. 

   
   
  22.                 AppGlobals.getPackageManager().resolveIntent(   
    23. 

   
   
  23.                 intent, resolvedType,   
    24. 

   
   
  24.                 PackageManager.MATCH_DEFAULT_ONLY   
    25. 

   
   
  25.                 | ActivityManagerService.STOCK_PM_FLAGS);   
    26. 

   
   
  26.             aInfo = rInfo != null ? rInfo.activityInfo : null;   
    27. 

   
   
  27.         } catch (RemoteException e) {   
    28. 

   
   
  28.             ......   
    29. 

   
   
  29.         }   
    30. 

   
   
  30.    
    31. 

   
   
  31.         if (aInfo != null) {   
    32. 

   
   
  32.             // Store the found target back into the intent, because now that   
    33. 

   
   
  33.             // we have it we never want to do this again.  For example, if the   
    34. 

   
   
  34.             // user navigates back to this point in the history, we should   
    35. 

   
   
  35.             // always restart the exact same activity.   
    36. 

   
   
  36.             intent.setComponent(new ComponentName(   
    37. 

   
   
  37.                 aInfo.applicationInfo.packageName, aInfo.name));   
    38. 

   
   
  38.             ......   
    39. 

   
   
  39.         }   
    40. 

   
   
  40.    
    41. 

   
   
  41.         synchronized (mService) {   
    42. 

   
   
  42.             int callingPid;   
    43. 

   
   
  43.             int callingUid;   
    44. 

   
   
  44.             if (caller == null) {   
    45. 

   
   
  45.                 ......   
    46. 

   
   
  46.             } else {   
    47. 

   
   
  47.                 callingPid = callingUid = -1;   
    48. 

   
   
  48.             }   
    49. 

   
   
  49.    
    50. 

   
   
  50.             mConfigWillChange = config != null   
    51. 

   
   
  51.                 && mService.mConfiguration.diff(config) != 0;   
    52. 

   
   
  52.    
    53. 

   
   
  53.             ......   
    54. 

   
   
  54.    
    55. 

   
   
  55.             if (mMainStack && aInfo != null &&   
    56. 

   
   
  56.                 (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {   
    57. 

   
   
  57.                      
    58. 

   
   
  58.                       ......   
    59. 

   
   
  59.    
    60. 

   
   
  60.             }   
    61. 

   
   
  61.    
    62. 

   
   
  62.             int res = startActivityLocked(caller, intent, resolvedType,   
    63. 

   
   
  63.                 grantedUriPermissions, grantedMode, aInfo,   
    64. 

   
   
  64.                 resultTo, resultWho, requestCode, callingPid, callingUid,   
    65. 

   
   
  65.                 onlyIfNeeded, componentSpecified);   
    66. 

   
   
  66.    
    67. 

   
   
  67.             if (mConfigWillChange && mMainStack) {   
    68. 

   
   
  68.                 ......   
    69. 

   
   
  69.             }   
    70. 

   
   
  70.    
    71. 

   
   
  71.             ......   
    72. 

   
   
  72.    
    73. 

   
   
  73.             if (outResult != null) {   
    74. 

   
   
  74.                 ......   
    75. 

   
   
  75.             }   
    76. 

   
   
  76.    
    77. 

   
   
  77.             return res;   
    78. 

   
   
  78.         }   
    79. 

   
   
  79.    
    80. 

   
   
  80.     }   
    81. 

   
   
  81.    
    82. 

   
   
  82.     ......   
    83. 

   
   
  83.    
    84. 

   
   
  84. }   
    85.

 

        注意，从Step 6传下来的参数outResult和config均为null，此外，表达式(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0为false，因此，这里忽略了无关代码。

 

        下面语句对参数intent的内容进行解析，得到MainActivity的相关信息，保存在aInfo变量中：


  
  
    

   
   
  1.    ActivityInfo aInfo;   
    2. 

   
   
  2.    try {   
    3. 

   
   
  3. ResolveInfo rInfo =   
    4. 

   
   
  4. AppGlobals.getPackageManager().resolveIntent(   
    5. 

   
   
  5.     intent, resolvedType,   
    6. 

   
   
  6.     PackageManager.MATCH_DEFAULT_ONLY   
    7. 

   
   
  7.     | ActivityManagerService.STOCK_PM_FLAGS);   
    8. 

   
   
  8. aInfo = rInfo != null ? rInfo.activityInfo : null;   
    9. 

   
   
  9.    } catch (RemoteException e) {   
    10. 

   
   
  10.     ......   
    11. 

   
   
  11.    }   
    12.

        解析之后，得到的aInfo.applicationInfo.packageName的值为"shy.luo.activity"，aInfo.name的值为"shy.luo.activity.MainActivity"，这是在这个实例的配置文件AndroidManifest.xml里面配置的。

        此外，函数开始的地方调用intent.getComponent()函数的返回值不为null，因此，这里的componentSpecified变量为true。

        接下去就调用startActivityLocked进一步处理了。





本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/965994，如需转载请自行联系原作者

文章标签：
Android开发
Java
监控
关键词：
Android应用
Android分析
Android源代码
Android应用程序
Android启动过程
余二五
目录
相关文章
土木林森
|
1月前
|
开发框架 前端开发 Android开发
Flutter 与原生模块（Android 和 iOS）之间的通信机制，包括方法调用、事件传递等，分析了通信的必要性、主要方式、数据传递、性能优化及错误处理，并通过实际案例展示了其应用效果，展望了未来的发展趋势
本文深入探讨了 Flutter 与原生模块（Android 和 iOS）之间的通信机制，包括方法调用、事件传递等，分析了通信的必要性、主要方式、数据传递、性能优化及错误处理，并通过实际案例展示了其应用效果，展望了未来的发展趋势。这对于实现高效的跨平台移动应用开发具有重要指导意义。
土木林森
175 4
aliyun0641063962-48771
|
1月前
|
安全 Android开发 数据安全/隐私保护
深入探讨iOS与Android系统安全性对比分析
在移动操作系统领域，iOS和Android无疑是两大巨头。本文从技术角度出发，对这两个系统的架构、安全机制以及用户隐私保护等方面进行了详细的比较分析。通过深入探讨，我们旨在揭示两个系统在安全性方面的差异，并为用户提供一些实用的安全建议。
aliyun0641063962-48771
104 3
请看我回答~
|
25天前
|
JSON Java API
探索安卓开发：打造你的首个天气应用
在这篇技术指南中，我们将一起潜入安卓开发的海洋，学习如何从零开始构建一个简单的天气应用。通过这个实践项目，你将掌握安卓开发的核心概念、界面设计、网络编程以及数据解析等技能。无论你是初学者还是有一定基础的开发者，这篇文章都将为你提供一个清晰的路线图和实用的代码示例，帮助你在安卓开发的道路上迈出坚实的一步。让我们一起开始这段旅程，打造属于你自己的第一个安卓应用吧！
请看我回答~
54 14
肥猪肥猪-17824
|
28天前
|
Java Linux 数据库
探索安卓开发：打造你的第一款应用
在数字时代的浪潮中，每个人都有机会成为创意的实现者。本文将带你走进安卓开发的奇妙世界，通过浅显易懂的语言和实际代码示例，引导你从零开始构建自己的第一款安卓应用。无论你是编程新手还是希望拓展技术的开发者，这篇文章都将为你打开一扇门，让你的创意和技术一起飞扬。
肥猪肥猪-17824
54 13
shuj
|
29天前
|
Java 开发工具 Android开发
安卓与iOS开发环境对比分析
在移动应用开发的广阔天地中，安卓和iOS两大平台各自占据半壁江山。本文深入探讨了这两个平台的开发环境，从编程语言、开发工具到用户界面设计等多个角度进行比较。通过实际案例分析和代码示例，我们旨在为开发者提供一个清晰的指南，帮助他们根据项目需求和个人偏好做出明智的选择。无论你是初涉移动开发领域的新手，还是寻求跨平台解决方案的资深开发者，这篇文章都将为你提供宝贵的信息和启示。
shuj
30 8
游客qf4jmczx4xu2y
|
26天前
|
搜索推荐 前端开发 测试技术
打造个性化安卓应用：从设计到开发的全面指南
在这个数字时代，拥有一个定制的移动应用不仅是一种趋势，更是个人或企业品牌的重要延伸。本文将引导你通过一系列简单易懂的步骤，从构思你的应用理念开始，直至实现一个功能齐全的安卓应用。无论你是编程新手还是希望拓展技能的开发者，这篇文章都将为你提供必要的工具和知识，帮助你将创意转化为现实。
游客qf4jmczx4xu2y
42 2
mzlogin
|
2月前
|
缓存 Java Shell
Android 系统缓存扫描与清理方法分析
Android 系统缓存从原理探索到实现。
mzlogin
86 15
Android 系统缓存扫描与清理方法分析
xibeijing
|
1月前
|
安全 Android开发 数据安全/隐私保护
深入探索Android与iOS系统安全性的对比分析
在当今数字化时代，移动操作系统的安全已成为用户和开发者共同关注的重点。本文旨在通过比较Android与iOS两大主流操作系统在安全性方面的差异，揭示两者在设计理念、权限管理、应用审核机制等方面的不同之处。我们将探讨这些差异如何影响用户的安全体验以及可能带来的风险。
xibeijing
41 1
mrq4nk6ni2neg
|
26天前
|
Java Android开发 开发者
探索安卓开发：构建你的第一个“Hello World”应用
在安卓开发的浩瀚海洋中，每个新手都渴望扬帆起航。本文将作为你的指南针，引领你通过创建一个简单的“Hello World”应用，迈出安卓开发的第一步。我们将一起搭建开发环境、了解基本概念，并编写第一行代码。就像印度圣雄甘地所说：“你必须成为你希望在世界上看到的改变。”让我们一起开始这段旅程，成为我们想要见到的开发者吧！
mrq4nk6ni2neg
35 0
我不是游客20240119
|
1月前
|
JSON Java Android开发
探索安卓开发之旅：打造你的第一个天气应用
【10月更文挑战第30天】在这个数字时代，掌握移动应用开发技能无疑是进入IT行业的敲门砖。本文将引导你开启安卓开发的奇妙之旅，通过构建一个简易的天气应用来实践你的编程技能。无论你是初学者还是有一定经验的开发者，这篇文章都将成为你宝贵的学习资源。我们将一步步地深入到安卓开发的世界中，从搭建开发环境到实现核心功能，每个环节都充满了发现和创造的乐趣。让我们开始吧，一起在代码的海洋中航行！
我不是游客20240119
42 2