android程序_android程序员指南 - CSDN
精华内容
参与话题
  • Android开发一个闹钟

    万次阅读 多人点赞 2020-07-30 14:20:20
    源码下载地址 GitHub地址https://github.com/jh360twb/Alarmalert-csdn CSDN积分下载https://download.csdn.net/download/qq873044564/11834458 网盘下载地址 链接:... ...最新2019年10月7...

    源码下载地址

    GitHub地址https://github.com/jh360twb/Alarmalert-csdn

    CSDN积分下载https://download.csdn.net/download/qq873044564/11834458

     

    最新2019年10月7日(趁着国庆有时间)更新了一波,界面好看了很多,但还是有很多地方不完善,以后抽时间再次更新

    不完善的地方:

    不能同时开多个闹钟,这个有点困难,有想法的同学可以告我怎么做

    后台程序无法长期保存,这个应该没有办法解决,因为不是系统级别的应用

    所以只是用来学习交流的,主要掌握定时器的用法就行了

    效果图如图:

     

    顺便说一下我用得编译器是Android Studio 

    下面讲解一下关键的几个步骤:(并非全部代码)

    首先我用的是Litepal数据库

    所以先新建了一个表

    public class Clock extends DataSupport {
        public static final int clock_open = 1;
        public static final int clock_close = 0;
    
        String hour;
        String minute;
        String content;
        int  ClockType;
    
        public String getMinute() {
            return minute;
        }
    
        public String getHour() {
            return hour;
        }
    
        public void setHour(String hour) {
            this.hour = hour;
        }
    
        public void setMinute(String minute) {
            this.minute = minute;
        }
    
        public int getClockType() {
            return ClockType;
        }
    
        public void setClockType(int clockType) {
            ClockType = clockType;
        }
    
        public String getContent() {
            return content;
        }
    
        public void setContent(String content) {
            this.content = content;
        }
    
    
    }

    然后比较重要的代码修改,保存和删除(这里用了定时器服务,会在指定时间发出广播)

    case R.id.set_time:
                    calendar.setTimeInMillis(System.currentTimeMillis());
                    int mhour = calendar.get(Calendar.HOUR_OF_DAY);
                    int mminute = calendar.get(Calendar.MINUTE);
                    new TimePickerDialog(ClockDetail.this, new TimePickerDialog.OnTimeSetListener() {
                        @Override
                        public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
                            //calendar.setTimeInMillis(System.currentTimeMillis());
                            calendar.set(Calendar.HOUR_OF_DAY, hourOfDay);
                            calendar.set(Calendar.MINUTE, minute);
                            calendar.set(Calendar.SECOND, 0);
                            calendar.set(Calendar.MILLISECOND, 0);
                            hourformat = format(hourOfDay);
                            minuteformat = format(minute);
                            Toast.makeText(ClockDetail.this, "" + hourformat + ":" + minuteformat, Toast.LENGTH_SHORT).show();
                            show_hour.setText(hourformat);
                            show_minute.setText(minuteformat);
                        }
                    }, mhour, mminute, true).show();
                    break;
                case R.id.save:
                    clock.setHour(hourformat);
                    clock.setMinute(minuteformat);
                    clock.setContent("" + content.getText().toString());
                    clock.setClockType(Clock.clock_open);
                    clock.save();
                    Intent intent = new Intent(ClockDetail.this, CallAlarm.class);
                   // intent.putExtra("content",clock.getContent());
                    //sendBroadcast(intent);
                    PendingIntent sender = PendingIntent.getBroadcast(
                            ClockDetail.this, 0, intent, 0);
                    AlarmManager am;
                    am = (AlarmManager) getSystemService(ALARM_SERVICE);
                    Log.e("gethour",clock.getHour());
                    Log.e("gethour",clock.getMinute());
                    calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(clock.getHour()));
                    calendar.set(Calendar.MINUTE, Integer.parseInt(clock.getMinute()));
                    Log.e("TAG",calendar.getTimeInMillis()+"");
                    Log.e("TAG",System.currentTimeMillis()+"");
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                        if (System.currentTimeMillis()>calendar.getTimeInMillis()+60000){
                            //加24小时
                            am.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis()+86400000, sender);
                        }else {
                            am.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), sender);
                        }
                    }
    
                    timeAdapter.notifyDataSetChanged();
                    finish();
                    break;
                case R.id.delete:
                    clock.delete();
                    timeAdapter.notifyDataSetChanged();
                    Intent intent1 = new Intent(context, CallAlarm.class);
                    PendingIntent sender1=PendingIntent.getBroadcast(
                            context,0, intent1, 0);
                    am =(AlarmManager)context.getSystemService(ALARM_SERVICE);
                    am.cancel(sender1);
                    finish();
                    break;

    广播接受者(接收指定时间发过来的广播)

    public class CallAlarm extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Intent intent1 = new Intent(context,AlarmAlert.class);
            Bundle bundle = new Bundle();
            bundle.putString("STR_CALLER","");
            intent1.putExtras(bundle);
            intent1.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            context.startActivity(intent1);
        }
    }
    

    收到广播后会跳转到这里 

    public class AlarmAlert extends Activity {
        private MediaPlayer mediaPlayer;
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            int position = getIntent().getIntExtra("position",-1);
            mediaPlayer = MediaPlayer.create(this,R.raw.clockmusic2);
            mediaPlayer.start();
            new AlertDialog.Builder(AlarmAlert.this)
                    .setIcon(R.drawable.clock)
                    .setTitle("闹钟响了")
                    .setCancelable(false)
                    .setMessage("时间到了!")
                    .setPositiveButton("关掉"
                            , new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                    AlarmAlert.this.finish();
                                    mediaPlayer.stop();
                                }
                            }).show();
        }
    }

    最后再贴一下Adapter里的代码吧,感觉这块的逻辑也挺重要的

    package com.example.dell.alarmalert_csdn;
    
    
    public class TimeAdapter extends RecyclerView.Adapter<TimeAdapter.ViewHolder> {
        List<Clock> list;
        LayoutInflater layoutInflater;
        Context context;
        Calendar calendar = Calendar.getInstance();
        public static int pos;
    
    
    
        public TimeAdapter(List<Clock> list, Context context) {
            this.list = list;
            this.context = context;
            layoutInflater = LayoutInflater.from(context);
        }
    
        @Override
        public TimeAdapter.ViewHolder onCreateViewHolder(@NonNull ViewGroup viewGroup, int i) {
            View view = layoutInflater.inflate(R.layout.clockitem, null);
            ViewHolder viewHolder = new ViewHolder(view);
            return viewHolder;
        }
    
        @SuppressLint({"ResourceAsColor", "SetTextI18n"})
        @Override
        public void onBindViewHolder(@NonNull final TimeAdapter.ViewHolder viewHolder, final int i) {
            final Clock clock = list.get(i);
            pos = i;
    
            Log.e("i=======",i+"  "+clock.getClockType());
            if (clock.getClockType() == Clock.clock_open){
                viewHolder.aSwitch.setChecked(true);
                viewHolder.hour.setTextColor(context.getResources().getColor(R.color.colorBlack));
                viewHolder.minute.setTextColor(context.getResources().getColor(R.color.colorBlack));
                viewHolder.net.setTextColor(context.getResources().getColor(R.color.colorBlack));
                viewHolder.content.setTextColor(context.getResources().getColor(R.color.colorBlack));
            }else if (clock.getClockType() == Clock.clock_close){
                viewHolder.aSwitch.setChecked(false);
                viewHolder.hour.setTextColor(context.getResources().getColor(R.color.colorGray));
                viewHolder.minute.setTextColor(context.getResources().getColor(R.color.colorGray));
                viewHolder.net.setTextColor(context.getResources().getColor(R.color.colorGray));
                viewHolder.content.setTextColor(context.getResources().getColor(R.color.colorGray));
            }
            viewHolder.hour.setText(clock.getHour()+"");
            viewHolder.minute.setText(clock.getMinute()+"");
    
            viewHolder.content.setText(clock.getContent());
            viewHolder.todetail.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Log.e("TODETAIL",clock.getClockType()+"");
                    Intent intent = new Intent(context, ClockDetail.class);
                    intent.putExtra("position", i);
                    context.startActivity(intent);
                }
            });
    
            viewHolder.aSwitch.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
                @SuppressLint("ResourceAsColor")
                @Override
                public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                    if (isChecked) {
                        clock.setClockType(Clock.clock_open);
                        //clock.updateAll();
                        clock.save();
                        Toast.makeText(context, "开启闹钟", Toast.LENGTH_SHORT).show();
                        viewHolder.hour.setTextColor(context.getResources().getColor(R.color.colorBlack));
                        viewHolder.minute.setTextColor(context.getResources().getColor(R.color.colorBlack));
                        viewHolder.net.setTextColor(context.getResources().getColor(R.color.colorBlack));
                        viewHolder.content.setTextColor(context.getResources().getColor(R.color.colorBlack));
                        Intent intent = new Intent(context, CallAlarm.class);
                        PendingIntent sender = PendingIntent.getBroadcast(
                                context, 0, intent, 0);
                        AlarmManager am;
                        am = (AlarmManager) context.getSystemService(ALARM_SERVICE);
                        calendar.setTimeInMillis(System.currentTimeMillis());
                        calendar.set(Calendar.HOUR_OF_DAY, Integer.parseInt(clock.getHour()));
                        calendar.set(Calendar.MINUTE, Integer.parseInt(clock.getMinute()));
                        calendar.set(Calendar.SECOND, 0);
                        calendar.set(Calendar.MILLISECOND, 0);
                        Log.e("TAG",calendar.getTimeInMillis()+"");
                        Log.e("TAG",System.currentTimeMillis()+"");
                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                            if (System.currentTimeMillis()>calendar.getTimeInMillis()+40000){
                                //加24小时
                                am.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis()+86400000, sender);
                            }else {
                                am.setExact(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), sender);
                            }
                        }
                    } else if (!isChecked){
                        clock.setClockType(Clock.clock_close);
                        //clock.updateAll();
                        clock.save();
                        Log.e("status------",clock.getHour()+clock.getMinute()+clock.getMinute()+clock.getClockType()+"");
    
                        Log.e("关闭闹钟",clock.getClockType()+"");
                        Intent intent = new Intent(context, CallAlarm.class);
                        PendingIntent sender=PendingIntent.getBroadcast(
                                context,0, intent, 0);
                        AlarmManager am;
                        am =(AlarmManager)context.getSystemService(ALARM_SERVICE);
                        am.cancel(sender);
                        Toast.makeText(context, "关闭闹钟", Toast.LENGTH_SHORT).show();
                        viewHolder.hour.setTextColor(context.getResources().getColor(R.color.colorGray));
                        viewHolder.minute.setTextColor(context.getResources().getColor(R.color.colorGray));
                        viewHolder.net.setTextColor(context.getResources().getColor(R.color.colorGray));
                        viewHolder.content.setTextColor(context.getResources().getColor(R.color.colorGray));
                    }
                }
            });
        }
    
        @Override
        public int getItemCount() {
            return list.size();
        }
    
        public class ViewHolder extends RecyclerView.ViewHolder {
            TextView hour;
            TextView minute;
            TextView content;
            TextView net;
            Switch aSwitch;
            LinearLayout todetail;
    
            public ViewHolder(@NonNull View itemView) {
                super(itemView);
                hour = itemView.findViewById(R.id.hour);
                minute = itemView.findViewById(R.id.minute);
                net = itemView.findViewById(R.id.net);
                content = itemView.findViewById(R.id.content_item);
                aSwitch = itemView.findViewById(R.id.switch_control);
                todetail = itemView.findViewById(R.id.todetail);
            }
        }
    }
    

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Android应用程序启动过程源代码分析

    万次阅读 多人点赞 2017-01-06 14:32:12
    Android系统中,应用程序是由Activity组成的,因此,应用程序的启动过程实际上就是应用程序中的默认Activity的启动过程,本文将详细分析应用程序框架层的源代码,了解Android应用程序的启动过程。 在上一篇文章...

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

    《Android系统源代码情景分析》一书正在进击的程序员网(http://0xcc0xcd.com)中连载,点击进入!

            在上一篇文章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文件中:

    /**
    * Default launcher application.
    */
    public final class Launcher extends Activity
    		implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {
    
    	......
    
    	/**
    	* Launches the intent referred by the clicked shortcut.
    	*
    	* @param v The view representing the clicked shortcut.
    	*/
    	public void onClick(View v) {
    		Object tag = v.getTag();
    		if (tag instanceof ShortcutInfo) {
    			// Open shortcut
    			final Intent intent = ((ShortcutInfo) tag).intent;
    			int[] pos = new int[2];
    			v.getLocationOnScreen(pos);
    			intent.setSourceBounds(new Rect(pos[0], pos[1],
    				pos[0] + v.getWidth(), pos[1] + v.getHeight()));
    			startActivitySafely(intent, tag);
    		} else if (tag instanceof FolderInfo) {
    			......
    		} else if (v == mHandleView) {
    			......
    		}
    	}
    
    	void startActivitySafely(Intent intent, Object tag) {
    		intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    		try {
    			startActivity(intent);
    		} catch (ActivityNotFoundException e) {
    			......
    		} catch (SecurityException e) {
    			......
    		}
    	}
    
    	......
    
    }
            回忆一下前面一篇文章Android应用程序的Activity启动过程简要介绍和学习计划说到的应用程序Activity,它的默认Activity是MainActivity,这里是AndroidManifest.xml文件中配置的:

    <activity android:name=".MainActivity"  
          android:label="@string/app_name">  
           <intent-filter>  
            <action android:name="android.intent.action.MAIN" />  
            <category android:name="android.intent.category.LAUNCHER" />  
        </intent-filter>  
    </activity>  
            因此,这里的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文件中:

    public class Activity extends ContextThemeWrapper
    		implements LayoutInflater.Factory,
    		Window.Callback, KeyEvent.Callback,
    		OnCreateContextMenuListener, ComponentCallbacks {
    
    	......
    
    	@Override
    	public void startActivity(Intent intent) {
    		startActivityForResult(intent, -1);
    	}
    
    	......
    
    }
            这个函数实现很简单,它调用startActivityForResult来进一步处理,第二个参数传入-1表示不需要这个Actvity结束后的返回结果。

            Step 3. Activity.startActivityForResult

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

    public class Activity extends ContextThemeWrapper
    		implements LayoutInflater.Factory,
    		Window.Callback, KeyEvent.Callback,
    		OnCreateContextMenuListener, ComponentCallbacks {
    
    	......
    
    	public void startActivityForResult(Intent intent, int requestCode) {
    		if (mParent == null) {
    			Instrumentation.ActivityResult ar =
    				mInstrumentation.execStartActivity(
    				this, mMainThread.getApplicationThread(), mToken, this,
    				intent, requestCode);
    			......
    		} else {
    			......
    		}
    
    
    	......
    
    }
             这里的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文件中:

    public class Instrumentation {
    
    	......
    
    	public ActivityResult execStartActivity(
    	Context who, IBinder contextThread, IBinder token, Activity target,
    	Intent intent, int requestCode) {
    		IApplicationThread whoThread = (IApplicationThread) contextThread;
    		if (mActivityMonitors != null) {
    			......
    		}
    		try {
    			int result = ActivityManagerNative.getDefault()
    				.startActivity(whoThread, intent,
    				intent.resolveTypeIfNeeded(who.getContentResolver()),
    				null, 0, token, target != null ? target.mEmbeddedID : null,
    				requestCode, false, false);
    			......
    		} catch (RemoteException e) {
    		}
    		return null;
    	}
    
    	......
    
    }
             这里的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文件中:

    class ActivityManagerProxy implements IActivityManager
    {
    
    	......
    
    	public int startActivity(IApplicationThread caller, Intent intent,
    			String resolvedType, Uri[] grantedUriPermissions, int grantedMode,
    			IBinder resultTo, String resultWho,
    			int requestCode, boolean onlyIfNeeded,
    			boolean debug) throws RemoteException {
    		Parcel data = Parcel.obtain();
    		Parcel reply = Parcel.obtain();
    		data.writeInterfaceToken(IActivityManager.descriptor);
    		data.writeStrongBinder(caller != null ? caller.asBinder() : null);
    		intent.writeToParcel(data, 0);
    		data.writeString(resolvedType);
    		data.writeTypedArray(grantedUriPermissions, 0);
    		data.writeInt(grantedMode);
    		data.writeStrongBinder(resultTo);
    		data.writeString(resultWho);
    		data.writeInt(requestCode);
    		data.writeInt(onlyIfNeeded ? 1 : 0);
    		data.writeInt(debug ? 1 : 0);
    		mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
    		reply.readException();
    		int result = reply.readInt();
    		reply.recycle();
    		data.recycle();
    		return result;
    	}
    
    	......
    
    }
            这里的参数比较多,我们先整理一下。从上面的调用可以知道,这里的参数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文件中:

    public final class ActivityManagerService extends ActivityManagerNative
    		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    
    	......
    
    	public final int startActivity(IApplicationThread caller,
    			Intent intent, String resolvedType, Uri[] grantedUriPermissions,
    			int grantedMode, IBinder resultTo,
    			String resultWho, int requestCode, boolean onlyIfNeeded,
    			boolean debug) {
    		return mMainStack.startActivityMayWait(caller, intent, resolvedType,
    			grantedUriPermissions, grantedMode, resultTo, resultWho,
    			requestCode, onlyIfNeeded, debug, null, null);
    	}
    
    
    	......
    
    }
            这里只是简单地将操作转发给成员变量mMainStack的startActivityMayWait函数,这里的mMainStack的类型为ActivityStack。

            Step 7. ActivityStack.startActivityMayWait

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

    public class ActivityStack {
    
    	......
    
    	final int startActivityMayWait(IApplicationThread caller,
    			Intent intent, String resolvedType, Uri[] grantedUriPermissions,
    			int grantedMode, IBinder resultTo,
    			String resultWho, int requestCode, boolean onlyIfNeeded,
    			boolean debug, WaitResult outResult, Configuration config) {
    
    		......
    
    		boolean componentSpecified = intent.getComponent() != null;
    
    		// Don't modify the client's object!
    		intent = new Intent(intent);
    
    		// Collect information about the target of the Intent.
    		ActivityInfo aInfo;
    		try {
    			ResolveInfo rInfo =
    				AppGlobals.getPackageManager().resolveIntent(
    				intent, resolvedType,
    				PackageManager.MATCH_DEFAULT_ONLY
    				| ActivityManagerService.STOCK_PM_FLAGS);
    			aInfo = rInfo != null ? rInfo.activityInfo : null;
    		} catch (RemoteException e) {
    			......
    		}
    
    		if (aInfo != null) {
    			// Store the found target back into the intent, because now that
    			// we have it we never want to do this again.  For example, if the
    			// user navigates back to this point in the history, we should
    			// always restart the exact same activity.
    			intent.setComponent(new ComponentName(
    				aInfo.applicationInfo.packageName, aInfo.name));
    			......
    		}
    
    		synchronized (mService) {
    			int callingPid;
    			int callingUid;
    			if (caller == null) {
    				......
    			} else {
    				callingPid = callingUid = -1;
    			}
    
    			mConfigWillChange = config != null
    				&& mService.mConfiguration.diff(config) != 0;
    
    			......
    
    			if (mMainStack && aInfo != null &&
    				(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {
    				  
    		              ......
    
    			}
    
    			int res = startActivityLocked(caller, intent, resolvedType,
    				grantedUriPermissions, grantedMode, aInfo,
    				resultTo, resultWho, requestCode, callingPid, callingUid,
    				onlyIfNeeded, componentSpecified);
    
    			if (mConfigWillChange && mMainStack) {
    				......
    			}
    
    			......
    
    			if (outResult != null) {
    				......
    			}
    
    			return res;
    		}
    
    	}
    
    	......
    
    }
            注意,从Step 6传下来的参数outResult和config均为null,此外,表达式(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0为false,因此,这里忽略了无关代码。

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

        ActivityInfo aInfo;
        try {
    	ResolveInfo rInfo =
    	AppGlobals.getPackageManager().resolveIntent(
    		intent, resolvedType,
    		PackageManager.MATCH_DEFAULT_ONLY
    		| ActivityManagerService.STOCK_PM_FLAGS);
    	aInfo = rInfo != null ? rInfo.activityInfo : null;
        } catch (RemoteException e) {
    		......
        }
            解析之后,得到的aInfo.applicationInfo.packageName的值为"shy.luo.activity",aInfo.name的值为"shy.luo.activity.MainActivity",这是在这个实例的配置文件AndroidManifest.xml里面配置的。

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

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

            Step 8. ActivityStack.startActivityLocked

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

    public class ActivityStack {
    
    	......
    
    	final int startActivityLocked(IApplicationThread caller,
    		    Intent intent, String resolvedType,
    		    Uri[] grantedUriPermissions,
    		    int grantedMode, ActivityInfo aInfo, IBinder resultTo,
    	            String resultWho, int requestCode,
    		    int callingPid, int callingUid, boolean onlyIfNeeded,
    		    boolean componentSpecified) {
    	        int err = START_SUCCESS;
    
    		ProcessRecord callerApp = null;
    		if (caller != null) {
    			callerApp = mService.getRecordForAppLocked(caller);
    			if (callerApp != null) {
    				callingPid = callerApp.pid;
    				callingUid = callerApp.info.uid;
    			} else {
    				......
    			}
    		}
    
    		......
    
    		ActivityRecord sourceRecord = null;
    		ActivityRecord resultRecord = null;
    		if (resultTo != null) {
    			int index = indexOfTokenLocked(resultTo);
    			
    			......
    				
    			if (index >= 0) {
    				sourceRecord = (ActivityRecord)mHistory.get(index);
    				if (requestCode >= 0 && !sourceRecord.finishing) {
    					......
    				}
    			}
    		}
    
    		int launchFlags = intent.getFlags();
    
    		if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0
    			&& sourceRecord != null) {
    			......
    		}
    
    		if (err == START_SUCCESS && intent.getComponent() == null) {
    			......
    		}
    
    		if (err == START_SUCCESS && aInfo == null) {
    			......
    		}
    
    		if (err != START_SUCCESS) {
    			......
    		}
    
    		......
    
    		ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
    			intent, resolvedType, aInfo, mService.mConfiguration,
    			resultRecord, resultWho, requestCode, componentSpecified);
    
    		......
    
    		return startActivityUncheckedLocked(r, sourceRecord,
    			grantedUriPermissions, grantedMode, onlyIfNeeded, true);
    	}
    
    
    	......
    
    }
            从传进来的参数caller得到调用者的进程信息,并保存在callerApp变量中,这里就是Launcher应用程序的进程信息了。

            前面说过,参数resultTo是Launcher这个Activity里面的一个Binder对象,通过它可以获得Launcher这个Activity的相关信息,保存在sourceRecord变量中。
            再接下来,创建即将要启动的Activity的相关信息,并保存在r变量中:

    ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,
    	intent, resolvedType, aInfo, mService.mConfiguration,
    	resultRecord, resultWho, requestCode, componentSpecified);
            接着调用startActivityUncheckedLocked函数进行下一步操作。

            Step 9. ActivityStack.startActivityUncheckedLocked

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

    public class ActivityStack {
    
    	......
    
    	final int startActivityUncheckedLocked(ActivityRecord r,
    		ActivityRecord sourceRecord, Uri[] grantedUriPermissions,
    		int grantedMode, boolean onlyIfNeeded, boolean doResume) {
    		final Intent intent = r.intent;
    		final int callingUid = r.launchedFromUid;
    
    		int launchFlags = intent.getFlags();
    
    		// We'll invoke onUserLeaving before onPause only if the launching
    		// activity did not explicitly state that this is an automated launch.
    		mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;
    		
    		......
    
    		ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)
    			!= 0 ? r : null;
    
    		// If the onlyIfNeeded flag is set, then we can do this if the activity
    		// being launched is the same as the one making the call...  or, as
    		// a special case, if we do not know the caller then we count the
    		// current top activity as the caller.
    		if (onlyIfNeeded) {
    			......
    		}
    
    		if (sourceRecord == null) {
    			......
    		} else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
    			......
    		} else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE
    			|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {
    			......
    		}
    
    		if (r.resultTo != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
    			......
    		}
    
    		boolean addingToTask = false;
    		if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
    			(launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
    			|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK
    			|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
    				// If bring to front is requested, and no result is requested, and
    				// we can find a task that was started with this same
    				// component, then instead of launching bring that one to the front.
    				if (r.resultTo == null) {
    					// See if there is a task to bring to the front.  If this is
    					// a SINGLE_INSTANCE activity, there can be one and only one
    					// instance of it in the history, and it is always in its own
    					// unique task, so we do a special search.
    					ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE
    						? findTaskLocked(intent, r.info)
    						: findActivityLocked(intent, r.info);
    					if (taskTop != null) {
    						......
    					}
    				}
    		}
    
    		......
    
    		if (r.packageName != null) {
    			// If the activity being launched is the same as the one currently
    			// at the top, then we need to check if it should only be launched
    			// once.
    			ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);
    			if (top != null && r.resultTo == null) {
    				if (top.realActivity.equals(r.realActivity)) {
    					......
    				}
    			}
    
    		} else {
    			......
    		}
    
    		boolean newTask = false;
    
    		// Should this be considered a new task?
    		if (r.resultTo == null && !addingToTask
    			&& (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
    				// todo: should do better management of integers.
    				mService.mCurTask++;
    				if (mService.mCurTask <= 0) {
    					mService.mCurTask = 1;
    				}
    				r.task = new TaskRecord(mService.mCurTask, r.info, intent,
    					(r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);
    				......
    				newTask = true;
    				if (mMainStack) {
    					mService.addRecentTaskLocked(r.task);
    				}
    
    		} else if (sourceRecord != null) {
    			......
    		} else {
    			......
    		}
    
    		......
    
    		startActivityLocked(r, newTask, doResume);
    		return START_SUCCESS;
    	}
    
    	......
    
    }
            函数首先获得intent的标志值,保存在launchFlags变量中。

            这个intent的标志值的位Intent.FLAG_ACTIVITY_NO_USER_ACTION没有置位,因此 ,成员变量mUserLeaving的值为true。

            这个intent的标志值的位Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP也没有置位,因此,变量notTop的值为null。

            由于在这个例子的AndroidManifest.xml文件中,MainActivity没有配置launchMode属值,因此,这里的r.launchMode为默认值0,表示以标准(Standard,或者称为ActivityInfo.LAUNCH_MULTIPLE)的方式来启动这个Activity。Activity的启动方式有四种,其余三种分别是ActivityInfo.LAUNCH_SINGLE_INSTANCE、ActivityInfo.LAUNCH_SINGLE_TASK和ActivityInfo.LAUNCH_SINGLE_TOP,具体可以参考官方网站http://developer.android.com/reference/android/content/pm/ActivityInfo.html

            传进来的参数r.resultTo为null,表示Launcher不需要等这个即将要启动的MainActivity的执行结果。

            由于这个intent的标志值的位Intent.FLAG_ACTIVITY_NEW_TASK被置位,而且Intent.FLAG_ACTIVITY_MULTIPLE_TASK没有置位,因此,下面的if语句会被执行:

        if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&
    	(launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)
    	|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK
    	|| r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {
    		// If bring to front is requested, and no result is requested, and
    		// we can find a task that was started with this same
    		// component, then instead of launching bring that one to the front.
    		if (r.resultTo == null) {
    			// See if there is a task to bring to the front.  If this is
    			// a SINGLE_INSTANCE activity, there can be one and only one
    			// instance of it in the history, and it is always in its own
    			// unique task, so we do a special search.
    			ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE
    				? findTaskLocked(intent, r.info)
    				: findActivityLocked(intent, r.info);
    			if (taskTop != null) {
    				......
    			}
    		}
        }
            这段代码的逻辑是查看一下,当前有没有Task可以用来执行这个Activity。由于r.launchMode的值不为ActivityInfo.LAUNCH_SINGLE_INSTANCE,因此,它通过findTaskLocked函数来查找存不存这样的Task,这里返回的结果是null,即taskTop为null,因此,需要创建一个新的Task来启动这个Activity。

            接着往下看:

        if (r.packageName != null) {
    	// If the activity being launched is the same as the one currently
    	// at the top, then we need to check if it should only be launched
    	// once.
    	ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);
    	if (top != null && r.resultTo == null) {
    		if (top.realActivity.equals(r.realActivity)) {
    			......
    		}
    	}
    
        } 
            这段代码的逻辑是看一下,当前在堆栈顶端的Activity是否就是即将要启动的Activity,有些情况下,如果即将要启动的Activity就在堆栈的顶端,那么,就不会重新启动这个Activity的别一个实例了,具体可以参考官方网站http://developer.android.com/reference/android/content/pm/ActivityInfo.html。现在处理堆栈顶端的Activity是Launcher,与我们即将要启动的MainActivity不是同一个Activity,因此,这里不用进一步处理上述介绍的情况。

           执行到这里,我们知道,要在一个新的Task里面来启动这个Activity了,于是新创建一个Task:

       if (r.resultTo == null && !addingToTask
    	&& (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {
    	// todo: should do better management of integers.
    	mService.mCurTask++;
    	if (mService.mCurTask <= 0) {
    		mService.mCurTask = 1;
    	}
    	r.task = new TaskRecord(mService.mCurTask, r.info, intent,
    		(r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);
    	......
    	newTask = true;
    	if (mMainStack) {
    		mService.addRecentTaskLocked(r.task);
    	}
    
        }
            新建的Task保存在r.task域中,同时,添加到mService中去,这里的mService就是ActivityManagerService了。

            最后就进入startActivityLocked(r, newTask, doResume)进一步处理了。这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中:

    public class ActivityStack {
    
    	......
    
    	private final void startActivityLocked(ActivityRecord r, boolean newTask,
    			boolean doResume) {
    		final int NH = mHistory.size();
    
    		int addPos = -1;
    
    		if (!newTask) {
    			......
    		}
    
    		// Place a new activity at top of stack, so it is next to interact
    		// with the user.
    		if (addPos < 0) {
    			addPos = NH;
    		}
    
    		// If we are not placing the new activity frontmost, we do not want
    		// to deliver the onUserLeaving callback to the actual frontmost
    		// activity
    		if (addPos < NH) {
    			......
    		}
    
    		// Slot the activity into the history stack and proceed
    		mHistory.add(addPos, r);
    		r.inHistory = true;
    		r.frontOfTask = newTask;
    		r.task.numActivities++;
    		if (NH > 0) {
    			// We want to show the starting preview window if we are
    			// switching to a new task, or the next activity's process is
    			// not currently running.
    			......
    		} else {
    			// If this is the first activity, don't do any fancy animations,
    			// because there is nothing for it to animate on top of.
    			......
    		}
    		
    		......
    
    		if (doResume) {
    			resumeTopActivityLocked(null);
    		}
    	}
    
    	......
    
    }
            这里的NH表示当前系统中历史任务的个数,这里肯定是大于0,因为Launcher已经跑起来了。当NH>0时,并且现在要切换新任务时,要做一些任务切的界面操作,这段代码我们就不看了,这里不会影响到下面启Activity的过程,有兴趣的读取可以自己研究一下。

            这里传进来的参数doResume为true,于是调用resumeTopActivityLocked进一步操作。

            Step 10. Activity.resumeTopActivityLocked

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

    public class ActivityStack {
    
    	......
    
    	/**
    	* Ensure that the top activity in the stack is resumed.
    	*
    	* @param prev The previously resumed activity, for when in the process
    	* of pausing; can be null to call from elsewhere.
    	*
    	* @return Returns true if something is being resumed, or false if
    	* nothing happened.
    	*/
    	final boolean resumeTopActivityLocked(ActivityRecord prev) {
    		// Find the first activity that is not finishing.
    		ActivityRecord next = topRunningActivityLocked(null);
    
    		// Remember how we'll process this pause/resume situation, and ensure
    		// that the state is reset however we wind up proceeding.
    		final boolean userLeaving = mUserLeaving;
    		mUserLeaving = false;
    
    		if (next == null) {
    			......
    		}
    
    		next.delayedResume = false;
    
    		// If the top activity is the resumed one, nothing to do.
    		if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
    			......
    		}
    
    		// If we are sleeping, and there is no resumed activity, and the top
    		// activity is paused, well that is the state we want.
    		if ((mService.mSleeping || mService.mShuttingDown)
    			&& mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
    			......
    		}
    
    		......
    
    		// If we are currently pausing an activity, then don't do anything
    		// until that is done.
    		if (mPausingActivity != null) {
    			......
    		}
    
    		......
    
    		// We need to start pausing the current activity so the top one
    		// can be resumed...
    		if (mResumedActivity != null) {
    			......
    			startPausingLocked(userLeaving, false);
    			return true;
    		}
    
    		......
    	}
    
    	......
    
    }
            函数先通过调用topRunningActivityLocked函数获得堆栈顶端的Activity,这里就是MainActivity了,这是在上面的Step 9设置好的,保存在next变量中。 

           接下来把mUserLeaving的保存在本地变量userLeaving中,然后重新设置为false,在上面的Step 9中,mUserLeaving的值为true,因此,这里的userLeaving为true。

           这里的mResumedActivity为Launcher,因为Launcher是当前正被执行的Activity。

           当我们处理休眠状态时,mLastPausedActivity保存堆栈顶端的Activity,因为当前不是休眠状态,所以mLastPausedActivity为null。

           有了这些信息之后,下面的语句就容易理解了:

        // If the top activity is the resumed one, nothing to do.
        if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
    	......
        }
    
        // If we are sleeping, and there is no resumed activity, and the top
        // activity is paused, well that is the state we want.
        if ((mService.mSleeping || mService.mShuttingDown)
    	&& mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
    	......
        }
            它首先看要启动的Activity是否就是当前处理Resumed状态的Activity,如果是的话,那就什么都不用做,直接返回就可以了;否则再看一下系统当前是否休眠状态,如果是的话,再看看要启动的Activity是否就是当前处于堆栈顶端的Activity,如果是的话,也是什么都不用做。

            上面两个条件都不满足,因此,在继续往下执行之前,首先要把当处于Resumed状态的Activity推入Paused状态,然后才可以启动新的Activity。但是在将当前这个Resumed状态的Activity推入Paused状态之前,首先要看一下当前是否有Activity正在进入Pausing状态,如果有的话,当前这个Resumed状态的Activity就要稍后才能进入Paused状态了,这样就保证了所有需要进入Paused状态的Activity串行处理。

            这里没有处于Pausing状态的Activity,即mPausingActivity为null,而且mResumedActivity也不为null,于是就调用startPausingLocked函数把Launcher推入Paused状态去了。

            Step 11. ActivityStack.startPausingLocked

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

    public class ActivityStack {
    
    	......
    
    	private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {
    		if (mPausingActivity != null) {
    			......
    		}
    		ActivityRecord prev = mResumedActivity;
    		if (prev == null) {
    			......
    		}
    		......
    		mResumedActivity = null;
    		mPausingActivity = prev;
    		mLastPausedActivity = prev;
    		prev.state = ActivityState.PAUSING;
    		......
    
    		if (prev.app != null && prev.app.thread != null) {
    			......
    			try {
    				......
    				prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving,
    					prev.configChangeFlags);
    				......
    			} catch (Exception e) {
    				......
    			}
    		} else {
    			......
    		}
    
    		......
    	
    	}
    
    	......
    
    }

            函数首先把mResumedActivity保存在本地变量prev中。在上一步Step 10中,说到mResumedActivity就是Launcher,因此,这里把Launcher进程中的ApplicationThread对象取出来,通过它来通知Launcher这个Activity它要进入Paused状态了。当然,这里的prev.app.thread是一个ApplicationThread对象的远程接口,通过调用这个远程接口的schedulePauseActivity来通知Launcher进入Paused状态。

           参数prev.finishing表示prev所代表的Activity是否正在等待结束的Activity列表中,由于Laucher这个Activity还没结束,所以这里为false;参数prev.configChangeFlags表示哪些config发生了变化,这里我们不关心它的值。

           Step 12. ApplicationThreadProxy.schedulePauseActivity

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

    class ApplicationThreadProxy implements IApplicationThread {
    	
    	......
    
    	public final void schedulePauseActivity(IBinder token, boolean finished,
    	boolean userLeaving, int configChanges) throws RemoteException {
    		Parcel data = Parcel.obtain();
    		data.writeInterfaceToken(IApplicationThread.descriptor);
    		data.writeStrongBinder(token);
    		data.writeInt(finished ? 1 : 0);
    		data.writeInt(userLeaving ? 1 :0);
    		data.writeInt(configChanges);
    		mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null,
    			IBinder.FLAG_ONEWAY);
    		data.recycle();
    	}
    
    	......
    
    }

            这个函数通过Binder进程间通信机制进入到ApplicationThread.schedulePauseActivity函数中。

            Step 13. ApplicationThread.schedulePauseActivity

            这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中,它是ActivityThread的内部类:

    public final class ActivityThread {
    	
    	......
    
    	private final class ApplicationThread extends ApplicationThreadNative {
    		
    		......
    
    		public final void schedulePauseActivity(IBinder token, boolean finished,
    				boolean userLeaving, int configChanges) {
    			queueOrSendMessage(
    				finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,
    				token,
    				(userLeaving ? 1 : 0),
    				configChanges);
    		}
    
    		......
    
    	}
    
    	......
    
    }
            这里调用的函数queueOrSendMessage是ActivityThread类的成员函数。

           上面说到,这里的finished值为false,因此,queueOrSendMessage的第一个参数值为H.PAUSE_ACTIVITY,表示要暂停token所代表的Activity,即Launcher。

           Step 14. ActivityThread.queueOrSendMessage

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

    public final class ActivityThread {
    	
    	......
    
    	private final void queueOrSendMessage(int what, Object obj, int arg1) {
    		queueOrSendMessage(what, obj, arg1, 0);
    	}
    
    	private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
    		synchronized (this) {
    			......
    			Message msg = Message.obtain();
    			msg.what = what;
    			msg.obj = obj;
    			msg.arg1 = arg1;
    			msg.arg2 = arg2;
    			mH.sendMessage(msg);
    		}
    	}
    
    	......
    
    }
            这里首先将相关信息组装成一个msg,然后通过mH成员变量发送出去,mH的类型是H,继承于Handler类,是ActivityThread的内部类,因此,这个消息最后由H.handleMessage来处理。

            Step 15. H.handleMessage

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

    public final class ActivityThread {
    	
    	......
    
    	private final class H extends Handler {
    
    		......
    
    		public void handleMessage(Message msg) {
    			......
    			switch (msg.what) {
    			
    			......
    			
    			case PAUSE_ACTIVITY:
    				handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);
    				maybeSnapshot();
    				break;
    
    			......
    
    			}
    		......
    
    	}
    
    	......
    
    }

            这里调用ActivityThread.handlePauseActivity进一步操作,msg.obj是一个ActivityRecord对象的引用,它代表的是Launcher这个Activity。
            Step 16. ActivityThread.handlePauseActivity

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

    public final class ActivityThread {
    	
    	......
    
    	private final void handlePauseActivity(IBinder token, boolean finished,
    			boolean userLeaving, int configChanges) {
    
    		ActivityClientRecord r = mActivities.get(token);
    		if (r != null) {
    			//Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);
    			if (userLeaving) {
    				performUserLeavingActivity(r);
    			}
    
    			r.activity.mConfigChangeFlags |= configChanges;
    			Bundle state = performPauseActivity(token, finished, true);
    
    			// Make sure any pending writes are now committed.
    			QueuedWork.waitToFinish();
    
    			// Tell the activity manager we have paused.
    			try {
    				ActivityManagerNative.getDefault().activityPaused(token, state);
    			} catch (RemoteException ex) {
    			}
    		}
    	}
    
    	......
    
    }
             函数首先将Binder引用token转换成ActivityRecord的远程接口ActivityClientRecord,然后做了三个事情:1. 如果userLeaving为true,则通过调用performUserLeavingActivity函数来调用Activity.onUserLeaveHint通知Activity,用户要离开它了;2. 调用performPauseActivity函数来调用Activity.onPause函数,我们知道,在Activity的生命周期中,当它要让位于其它的Activity时,系统就会调用它的onPause函数;3. 它通知ActivityManagerService,这个Activity已经进入Paused状态了,ActivityManagerService现在可以完成未竟的事情,即启动MainActivity了。

            Step 17. ActivityManagerProxy.activityPaused

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

    class ActivityManagerProxy implements IActivityManager
    {
    	......
    
    	public void activityPaused(IBinder token, Bundle state) throws RemoteException
    	{
    		Parcel data = Parcel.obtain();
    		Parcel reply = Parcel.obtain();
    		data.writeInterfaceToken(IActivityManager.descriptor);
    		data.writeStrongBinder(token);
    		data.writeBundle(state);
    		mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);
    		reply.readException();
    		data.recycle();
    		reply.recycle();
    	}
    
    	......
    
    }
            这里通过Binder进程间通信机制就进入到ActivityManagerService.activityPaused函数中去了。

            Step 18. ActivityManagerService.activityPaused

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

    public final class ActivityManagerService extends ActivityManagerNative
    			implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    	......
    
    	public final void activityPaused(IBinder token, Bundle icicle) {
    		
    		......
    
    		final long origId = Binder.clearCallingIdentity();
    		mMainStack.activityPaused(token, icicle, false);
    		
    		......
    	}
    
    	......
    
    }
           这里,又再次进入到ActivityStack类中,执行activityPaused函数。

           Step 19. ActivityStack.activityPaused

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

    public class ActivityStack {
    
    	......
    
    	final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {
    		
    		......
    
    		ActivityRecord r = null;
    
    		synchronized (mService) {
    			int index = indexOfTokenLocked(token);
    			if (index >= 0) {
    				r = (ActivityRecord)mHistory.get(index);
    				if (!timeout) {
    					r.icicle = icicle;
    					r.haveState = true;
    				}
    				mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
    				if (mPausingActivity == r) {
    					r.state = ActivityState.PAUSED;
    					completePauseLocked();
    				} else {
    					......
    				}
    			}
    		}
    	}
    
    	......
    
    }
           这里通过参数token在mHistory列表中得到ActivityRecord,从上面我们知道,这个ActivityRecord代表的是Launcher这个Activity,而我们在Step 11中,把Launcher这个Activity的信息保存在mPausingActivity中,因此,这里mPausingActivity等于r,于是,执行completePauseLocked操作。

           Step 20. ActivityStack.completePauseLocked

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

    public class ActivityStack {
    
    	......
    
    	private final void completePauseLocked() {
    		ActivityRecord prev = mPausingActivity;
    		
    		......
    
    		if (prev != null) {
    
    			......
    
    			mPausingActivity = null;
    		}
    
    		if (!mService.mSleeping && !mService.mShuttingDown) {
    			resumeTopActivityLocked(prev);
    		} else {
    			......
    		}
    
    		......
    	}
    
    	......
    
    }
            函数首先把mPausingActivity变量清空,因为现在不需要它了,然后调用resumeTopActivityLokced进一步操作,它传入的参数即为代表Launcher这个Activity的ActivityRecord。

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

    public class ActivityStack {
    
    	......
    
    	final boolean resumeTopActivityLocked(ActivityRecord prev) {
    		......
    
    		// Find the first activity that is not finishing.
    		ActivityRecord next = topRunningActivityLocked(null);
    
    		// Remember how we'll process this pause/resume situation, and ensure
    		// that the state is reset however we wind up proceeding.
    		final boolean userLeaving = mUserLeaving;
    		mUserLeaving = false;
    
    		......
    
    		next.delayedResume = false;
    
    		// If the top activity is the resumed one, nothing to do.
    		if (mResumedActivity == next && next.state == ActivityState.RESUMED) {
    			......
    			return false;
    		}
    
    		// If we are sleeping, and there is no resumed activity, and the top
    		// activity is paused, well that is the state we want.
    		if ((mService.mSleeping || mService.mShuttingDown)
    			&& mLastPausedActivity == next && next.state == ActivityState.PAUSED) {
    			......
    			return false;
    		}
    
    		.......
    
    
    		// We need to start pausing the current activity so the top one
    		// can be resumed...
    		if (mResumedActivity != null) {
    			......
    			return true;
    		}
    
    		......
    
    
    		if (next.app != null && next.app.thread != null) {
    			......
    
    		} else {
    			......
    			startSpecificActivityLocked(next, true, true);
    		}
    
    		return true;
    	}
    
    
    	......
    
    }
            通过上面的Step 9,我们知道,当前在堆栈顶端的Activity为我们即将要启动的MainActivity,这里通过调用topRunningActivityLocked将它取回来,保存在next变量中。之前最后一个Resumed状态的Activity,即Launcher,到了这里已经处于Paused状态了,因此,mResumedActivity为null。最后一个处于Paused状态的Activity为Launcher,因此,这里的mLastPausedActivity就为Launcher。前面我们为MainActivity创建了ActivityRecord后,它的app域一直保持为null。有了这些信息后,上面这段代码就容易理解了,它最终调用startSpecificActivityLocked进行下一步操作。

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

    public class ActivityStack {
    
    	......
    
    	private final void startSpecificActivityLocked(ActivityRecord r,
    			boolean andResume, boolean checkConfig) {
    		// Is this activity's application already running?
    		ProcessRecord app = mService.getProcessRecordLocked(r.processName,
    			r.info.applicationInfo.uid);
    
    		......
    
    		if (app != null && app.thread != null) {
    			try {
    				realStartActivityLocked(r, app, andResume, checkConfig);
    				return;
    			} catch (RemoteException e) {
    				......
    			}
    		}
    
    		mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
    			"activity", r.intent.getComponent(), false);
    	}
    
    
    	......
    
    }
            注意,这里由于是第一次启动应用程序的Activity,所以下面语句:

    ProcessRecord app = mService.getProcessRecordLocked(r.processName,
    	r.info.applicationInfo.uid);
            取回来的app为null。在Activity应用程序中的AndroidManifest.xml配置文件中,我们没有指定Application标签的process属性,系统就会默认使用package的名称,这里就是"shy.luo.activity"了。每一个应用程序都有自己的uid,因此,这里uid + process的组合就可以为每一个应用程序创建一个ProcessRecord。当然,我们可以配置两个应用程序具有相同的uid和package,或者在AndroidManifest.xml配置文件的application标签或者activity标签中显式指定相同的process属性值,这样,不同的应用程序也可以在同一个进程中启动。

           函数最终执行ActivityManagerService.startProcessLocked函数进行下一步操作。

           Step 23. ActivityManagerService.startProcessLocked

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

    public final class ActivityManagerService extends ActivityManagerNative
    		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    
    	......
    
    	final ProcessRecord startProcessLocked(String processName,
    			ApplicationInfo info, boolean knownToBeDead, int intentFlags,
    			String hostingType, ComponentName hostingName, boolean allowWhileBooting) {
    
    		ProcessRecord app = getProcessRecordLocked(processName, info.uid);
    		
    		......
    
    		String hostingNameStr = hostingName != null
    			? hostingName.flattenToShortString() : null;
    
    		......
    
    		if (app == null) {
    			app = new ProcessRecordLocked(null, info, processName);
    			mProcessNames.put(processName, info.uid, app);
    		} else {
    			// If this is a new package in the process, add the package to the list
    			app.addPackage(info.packageName);
    		}
    
    		......
    
    		startProcessLocked(app, hostingType, hostingNameStr);
    		return (app.pid != 0) ? app : null;
    	}
    
    	......
    
    }
            这里再次检查是否已经有以process + uid命名的进程存在,在我们这个情景中,返回值app为null,因此,后面会创建一个ProcessRecord,并存保存在成员变量mProcessNames中,最后,调用另一个startProcessLocked函数进一步操作:

    public final class ActivityManagerService extends ActivityManagerNative
    		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    
    	......
    
    	private final void startProcessLocked(ProcessRecord app,
    				String hostingType, String hostingNameStr) {
    
    		......
    
    		try {
    			int uid = app.info.uid;
    			int[] gids = null;
    			try {
    				gids = mContext.getPackageManager().getPackageGids(
    					app.info.packageName);
    			} catch (PackageManager.NameNotFoundException e) {
    				......
    			}
    			
    			......
    
    			int debugFlags = 0;
    			
    			......
    			
    			int pid = Process.start("android.app.ActivityThread",
    				mSimpleProcessManagement ? app.processName : null, uid, uid,
    				gids, debugFlags, null);
    			
    			......
    
    		} catch (RuntimeException e) {
    			
    			......
    
    		}
    	}
    
    	......
    
    }
            这里主要是调用Process.start接口来创建一个新的进程,新的进程会导入android.app.ActivityThread类,并且执行它的main函数,这就是为什么我们前面说每一个应用程序都有一个ActivityThread实例来对应的原因。

            Step 24. ActivityThread.main

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

    public final class ActivityThread {
    
    	......
    
    	private final void attach(boolean system) {
    		......
    
    		mSystemThread = system;
    		if (!system) {
    
    			......
    
    			IActivityManager mgr = ActivityManagerNative.getDefault();
    			try {
    				mgr.attachApplication(mAppThread);
    			} catch (RemoteException ex) {
    			}
    		} else {
    
    			......
    
    		}
    	}
    
    	......
    
    	public static final void main(String[] args) {
    		
    		.......
    
    		ActivityThread thread = new ActivityThread();
    		thread.attach(false);
    
    		......
    
    		Looper.loop();
    
    		.......
    
    		thread.detach();
    		
    		......
    	}
    }
           这个函数在进程中创建一个ActivityThread实例,然后调用它的attach函数,接着就进入消息循环了,直到最后进程退出。

           函数attach最终调用了ActivityManagerService的远程接口ActivityManagerProxy的attachApplication函数,传入的参数是mAppThread,这是一个ApplicationThread类型的Binder对象,它的作用是用来进行进程间通信的。

          Step 25. ActivityManagerProxy.attachApplication

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

    class ActivityManagerProxy implements IActivityManager
    {
    	......
    
    	public void attachApplication(IApplicationThread app) throws RemoteException
    	{
    		Parcel data = Parcel.obtain();
    		Parcel reply = Parcel.obtain();
    		data.writeInterfaceToken(IActivityManager.descriptor);
    		data.writeStrongBinder(app.asBinder());
    		mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);
    		reply.readException();
    		data.recycle();
    		reply.recycle();
    	}
    
    	......
    
    }
           这里通过Binder驱动程序,最后进入ActivityManagerService的attachApplication函数中。

           Step 26. ActivityManagerService.attachApplication

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

    public final class ActivityManagerService extends ActivityManagerNative
    		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    
    	......
    
    	public final void attachApplication(IApplicationThread thread) {
    		synchronized (this) {
    			int callingPid = Binder.getCallingPid();
    			final long origId = Binder.clearCallingIdentity();
    			attachApplicationLocked(thread, callingPid);
    			Binder.restoreCallingIdentity(origId);
    		}
    	}
    
    	......
    
    }
            这里将操作转发给attachApplicationLocked函数。

            Step 27. ActivityManagerService.attachApplicationLocked

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

    public final class ActivityManagerService extends ActivityManagerNative
    		implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    
    	......
    
    	private final boolean attachApplicationLocked(IApplicationThread thread,
    			int pid) {
    		// Find the application record that is being attached...  either via
    		// the pid if we are running in multiple processes, or just pull the
    		// next app record if we are emulating process with anonymous threads.
    		ProcessRecord app;
    		if (pid != MY_PID && pid >= 0) {
    			synchronized (mPidsSelfLocked) {
    				app = mPidsSelfLocked.get(pid);
    			}
    		} else if (mStartingProcesses.size() > 0) {
    			......
    		} else {
    			......
    		}
    
    		if (app == null) {
    			......
    			return false;
    		}
    
    		......
    
    		String processName = app.processName;
    		try {
    			thread.asBinder().linkToDeath(new AppDeathRecipient(
    				app, pid, thread), 0);
    		} catch (RemoteException e) {
    			......
    			return false;
    		}
    
    		......
    
    		app.thread = thread;
    		app.curAdj = app.setAdj = -100;
    		app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
    		app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
    		app.forcingToForeground = null;
    		app.foregroundServices = false;
    		app.debugging = false;
    
    		......
    
    		boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);
    
    		......
    
    		boolean badApp = false;
    		boolean didSomething = false;
    
    		// See if the top visible activity is waiting to run in this process...
    		ActivityRecord hr = mMainStack.topRunningActivityLocked(null);
    		if (hr != null && normalMode) {
    			if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid
    				&& processName.equals(hr.processName)) {
    					try {
    						if (mMainStack.realStartActivityLocked(hr, app, true, true)) {
    							didSomething = true;
    						}
    					} catch (Exception e) {
    						......
    					}
    			} else {
    				......
    			}
    		}
    
    		......
    
    		return true;
    	}
    
    	......
    
    }

            在前面的Step 23中,已经创建了一个ProcessRecord,这里首先通过pid将它取回来,放在app变量中,然后对app的其它成员进行初始化,最后调用mMainStack.realStartActivityLocked执行真正的Activity启动操作。这里要启动的Activity通过调用mMainStack.topRunningActivityLocked(null)从堆栈顶端取回来,这时候在堆栈顶端的Activity就是MainActivity了。

            Step 28. ActivityStack.realStartActivityLocked

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

    public class ActivityStack {
    
    	......
    
    	final boolean realStartActivityLocked(ActivityRecord r,
    			ProcessRecord app, boolean andResume, boolean checkConfig)
    			throws RemoteException {
    		
    		......
    
    		r.app = app;
    
    		......
    
    		int idx = app.activities.indexOf(r);
    		if (idx < 0) {
    			app.activities.add(r);
    		}
    		
    		......
    
    		try {
    			......
    
    			List<ResultInfo> results = null;
    			List<Intent> newIntents = null;
    			if (andResume) {
    				results = r.results;
    				newIntents = r.newIntents;
    			}
    	
    			......
    			
    			app.thread.scheduleLaunchActivity(new Intent(r.intent), r,
    				System.identityHashCode(r),
    				r.info, r.icicle, results, newIntents, !andResume,
    				mService.isNextTransitionForward());
    
    			......
    
    		} catch (RemoteException e) {
    			......
    		}
    
    		......
    
    		return true;
    	}
    
    	......
    
    }
            这里最终通过app.thread进入到ApplicationThreadProxy的scheduleLaunchActivity函数中,注意,这里的第二个参数r,是一个ActivityRecord类型的Binder对象,用来作来这个Activity的token值。

            Step 29. ApplicationThreadProxy.scheduleLaunchActivity
            这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中:

    class ApplicationThreadProxy implements IApplicationThread {
    
    	......
    
    	public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
    			ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
    			List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)
    			throws RemoteException {
    		Parcel data = Parcel.obtain();
    		data.writeInterfaceToken(IApplicationThread.descriptor);
    		intent.writeToParcel(data, 0);
    		data.writeStrongBinder(token);
    		data.writeInt(ident);
    		info.writeToParcel(data, 0);
    		data.writeBundle(state);
    		data.writeTypedList(pendingResults);
    		data.writeTypedList(pendingNewIntents);
    		data.writeInt(notResumed ? 1 : 0);
    		data.writeInt(isForward ? 1 : 0);
    		mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,
    			IBinder.FLAG_ONEWAY);
    		data.recycle();
    	}
    
    	......
    
    }
            这个函数最终通过Binder驱动程序进入到ApplicationThread的scheduleLaunchActivity函数中。

            Step 30. ApplicationThread.scheduleLaunchActivity
            这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中:

    public final class ActivityThread {
    
    	......
    
    	private final class ApplicationThread extends ApplicationThreadNative {
    
    		......
    
    		// we use token to identify this activity without having to send the
    		// activity itself back to the activity manager. (matters more with ipc)
    		public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,
    				ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,
    				List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {
    			ActivityClientRecord r = new ActivityClientRecord();
    
    			r.token = token;
    			r.ident = ident;
    			r.intent = intent;
    			r.activityInfo = info;
    			r.state = state;
    
    			r.pendingResults = pendingResults;
    			r.pendingIntents = pendingNewIntents;
    
    			r.startsNotResumed = notResumed;
    			r.isForward = isForward;
    
    			queueOrSendMessage(H.LAUNCH_ACTIVITY, r);
    		}
    
    		......
    
    	}
    
    	......
    }
             函数首先创建一个ActivityClientRecord实例,并且初始化它的成员变量,然后调用ActivityThread类的queueOrSendMessage函数进一步处理。

             Step 31. ActivityThread.queueOrSendMessage
             这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中:

    public final class ActivityThread {
    
    	......
    
    	private final class ApplicationThread extends ApplicationThreadNative {
    
    		......
    
    		// if the thread hasn't started yet, we don't have the handler, so just
    		// save the messages until we're ready.
    		private final void queueOrSendMessage(int what, Object obj) {
    			queueOrSendMessage(what, obj, 0, 0);
    		}
    
    		......
    
    		private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {
    			synchronized (this) {
    				......
    				Message msg = Message.obtain();
    				msg.what = what;
    				msg.obj = obj;
    				msg.arg1 = arg1;
    				msg.arg2 = arg2;
    				mH.sendMessage(msg);
    			}
    		}
    
    		......
    
    	}
    
    	......
    }
            函数把消息内容放在msg中,然后通过mH把消息分发出去,这里的成员变量mH我们在前面已经见过,消息分发出去后,最后会调用H类的handleMessage函数。

            Step 32. H.handleMessage

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

    public final class ActivityThread {
    
    	......
    
    	private final class H extends Handler {
    
    		......
    
    		public void handleMessage(Message msg) {
    			......
    			switch (msg.what) {
    			case LAUNCH_ACTIVITY: {
    				ActivityClientRecord r = (ActivityClientRecord)msg.obj;
    
    				r.packageInfo = getPackageInfoNoCheck(
    					r.activityInfo.applicationInfo);
    				handleLaunchActivity(r, null);
    			} break;
    			......
    			}
    
    		......
    
    	}
    
    	......
    }
            这里最后调用ActivityThread类的handleLaunchActivity函数进一步处理。

            Step 33. ActivityThread.handleLaunchActivity

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

    public final class ActivityThread {
    
    	......
    
    	private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    		......
    
    		Activity a = performLaunchActivity(r, customIntent);
    
    		if (a != null) {
    			r.createdConfig = new Configuration(mConfiguration);
    			Bundle oldState = r.state;
    			handleResumeActivity(r.token, false, r.isForward);
    
    			......
    		} else {
    			......
    		}
    	}
    
    	......
    }
            这里首先调用performLaunchActivity函数来加载这个Activity类,即shy.luo.activity.MainActivity,然后调用它的onCreate函数,最后回到handleLaunchActivity函数时,再调用handleResumeActivity函数来使这个Activity进入Resumed状态,即会调用这个Activity的onResume函数,这是遵循Activity的生命周期的。

            Step 34. ActivityThread.performLaunchActivity
            这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中:

    public final class ActivityThread {
    
    	......
    
    	private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    		
    		ActivityInfo aInfo = r.activityInfo;
    		if (r.packageInfo == null) {
    			r.packageInfo = getPackageInfo(aInfo.applicationInfo,
    				Context.CONTEXT_INCLUDE_CODE);
    		}
    
    		ComponentName component = r.intent.getComponent();
    		if (component == null) {
    			component = r.intent.resolveActivity(
    				mInitialApplication.getPackageManager());
    			r.intent.setComponent(component);
    		}
    
    		if (r.activityInfo.targetActivity != null) {
    			component = new ComponentName(r.activityInfo.packageName,
    				r.activityInfo.targetActivity);
    		}
    
    		Activity activity = null;
    		try {
    			java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
    			activity = mInstrumentation.newActivity(
    				cl, component.getClassName(), r.intent);
    			r.intent.setExtrasClassLoader(cl);
    			if (r.state != null) {
    				r.state.setClassLoader(cl);
    			}
    		} catch (Exception e) {
    			......
    		}
    
    		try {
    			Application app = r.packageInfo.makeApplication(false, mInstrumentation);
    
    			......
    
    			if (activity != null) {
    				ContextImpl appContext = new ContextImpl();
    				appContext.init(r.packageInfo, r.token, this);
    				appContext.setOuterContext(activity);
    				CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
    				Configuration config = new Configuration(mConfiguration);
    				......
    				activity.attach(appContext, this, getInstrumentation(), r.token,
    					r.ident, app, r.intent, r.activityInfo, title, r.parent,
    					r.embeddedID, r.lastNonConfigurationInstance,
    					r.lastNonConfigurationChildInstances, config);
    
    				if (customIntent != null) {
    					activity.mIntent = customIntent;
    				}
    				r.lastNonConfigurationInstance = null;
    				r.lastNonConfigurationChildInstances = null;
    				activity.mStartedActivity = false;
    				int theme = r.activityInfo.getThemeResource();
    				if (theme != 0) {
    					activity.setTheme(theme);
    				}
    
    				activity.mCalled = false;
    				mInstrumentation.callActivityOnCreate(activity, r.state);
    				......
    				r.activity = activity;
    				r.stopped = true;
    				if (!r.activity.mFinished) {
    					activity.performStart();
    					r.stopped = false;
    				}
    				if (!r.activity.mFinished) {
    					if (r.state != null) {
    						mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
    					}
    				}
    				if (!r.activity.mFinished) {
    					activity.mCalled = false;
    					mInstrumentation.callActivityOnPostCreate(activity, r.state);
    					if (!activity.mCalled) {
    						throw new SuperNotCalledException(
    							"Activity " + r.intent.getComponent().toShortString() +
    							" did not call through to super.onPostCreate()");
    					}
    				}
    			}
    			r.paused = true;
    
    			mActivities.put(r.token, r);
    
    		} catch (SuperNotCalledException e) {
    			......
    
    		} catch (Exception e) {
    			......
    		}
    
    		return activity;
    	}
    
    	......
    }

           函数前面是收集要启动的Activity的相关信息,主要package和component信息:

       ActivityInfo aInfo = r.activityInfo;
       if (r.packageInfo == null) {
            r.packageInfo = getPackageInfo(aInfo.applicationInfo,
                    Context.CONTEXT_INCLUDE_CODE);
       }
    
       ComponentName component = r.intent.getComponent();
       if (component == null) {
           component = r.intent.resolveActivity(
               mInitialApplication.getPackageManager());
           r.intent.setComponent(component);
       }
    
       if (r.activityInfo.targetActivity != null) {
           component = new ComponentName(r.activityInfo.packageName,
                   r.activityInfo.targetActivity);
       }
           然后通过ClassLoader将shy.luo.activity.MainActivity类加载进来:

       Activity activity = null;
       try {
    	java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
    	activity = mInstrumentation.newActivity(
    		cl, component.getClassName(), r.intent);
    	r.intent.setExtrasClassLoader(cl);
    	if (r.state != null) {
    		r.state.setClassLoader(cl);
    	}
       } catch (Exception e) {
    	......
       }
          接下来是创建Application对象,这是根据AndroidManifest.xml配置文件中的Application标签的信息来创建的:

       Application app = r.packageInfo.makeApplication(false, mInstrumentation);
          后面的代码主要创建Activity的上下文信息,并通过attach方法将这些上下文信息设置到MainActivity中去:

       activity.attach(appContext, this, getInstrumentation(), r.token,
    	r.ident, app, r.intent, r.activityInfo, title, r.parent,
    	r.embeddedID, r.lastNonConfigurationInstance,
    	r.lastNonConfigurationChildInstances, config);
          最后还要调用MainActivity的onCreate函数:

       mInstrumentation.callActivityOnCreate(activity, r.state);
          这里不是直接调用MainActivity的onCreate函数,而是通过mInstrumentation的callActivityOnCreate函数来间接调用,前面我们说过,mInstrumentation在这里的作用是监控Activity与系统的交互操作,相当于是系统运行日志。

          Step 35. MainActivity.onCreate

          这个函数定义在packages/experimental/Activity/src/shy/luo/activity/MainActivity.java文件中,这是我们自定义的app工程文件:

    public class MainActivity extends Activity  implements OnClickListener {
    	
    	......
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		......
    
    		Log.i(LOG_TAG, "Main Activity Created.");
    	}
    
    	......
    
    }
           这样,MainActivity就启动起来了,整个应用程序也启动起来了。

           整个应用程序的启动过程要执行很多步骤,但是整体来看,主要分为以下五个阶段:

           一. Step1 - Step 11:Launcher通过Binder进程间通信机制通知ActivityManagerService,它要启动一个Activity;

           二. Step 12 - Step 16:ActivityManagerService通过Binder进程间通信机制通知Launcher进入Paused状态;

           三. Step 17 - Step 24:Launcher通过Binder进程间通信机制通知ActivityManagerService,它已经准备就绪进入Paused状态,于是ActivityManagerService就创建一个新的进程,用来启动一个ActivityThread实例,即将要启动的Activity就是在这个ActivityThread实例中运行;

           四. Step 25 - Step 27:ActivityThread通过Binder进程间通信机制将一个ApplicationThread类型的Binder对象传递给ActivityManagerService,以便以后ActivityManagerService能够通过这个Binder对象和它进行通信;

           五. Step 28 - Step 35:ActivityManagerService通过Binder进程间通信机制通知ActivityThread,现在一切准备就绪,它可以真正执行Activity的启动操作了。

           这里不少地方涉及到了Binder进程间通信机制,相关资料请参考Android进程间通信(IPC)机制Binder简要介绍和学习计划一文。

           这样,应用程序的启动过程就介绍完了,它实质上是启动应用程序的默认Activity,在下一篇文章中,我们将介绍在应用程序内部启动另一个Activity的过程,即新的Activity与启动它的Activity将会在同一个进程(Process)和任务(Task)运行,敬请关注。

    老罗的新浪微博:http://weibo.com/shengyangluo,欢迎关注!

    展开全文
  • Android程序员的十大转型之路

    万次阅读 多人点赞 2017-06-21 15:47:44
    IT行业是一个瞬息万变的行业,程序员是一个不进则退的职业。我作为一个Android程序员,多年来一直保持随时可以转型其他技术领域的状态,保持对新技术敏感的嗅觉。

    IT行业是一个瞬息万变的行业,程序员是一个不进则退的职业。我作为一个Android程序员,多年来一直保持随时可以转型其他技术领域的状态,保持对新技术敏感的嗅觉。

     

    我先说说Android程序员不可能转型的几个方向,以下四个不靠谱方向的靠谱性递减:

    首先不会转型iOS,iOS和Android工程师的工作内容都是大同小异的。

    其次不会转型Windows Phone,好多Andr oid程序员就是受不了产品经理唠叨:“像QQ客户端那样做成和iOS一样”才转型的,怎么会转型比Android还难做成和iOS一样的WP?

    再次不会转型Windows和MacOS等桌面软件,桌面开发周期长、难度大、升级不易,这是一个已经接近穷途末路的夕阳产业。

    最后不会开JavaME或者Symbian的历史倒车,除非他有本事让每个用户都买(就一个“买”字,同时包含“想买”和“买得到”的意思)停产多年的机型。

     

    我观察如今的技术形势,并亲身探索了一个Android程序员转型的几个技术方向的可行性:

     

    Android病毒和恶意应用

    最近肆虐全世界的WannaCry让安全成了IT圈最热的话题,开发腻了善意应用的Android工程师最便捷的转型方向就是开发Android病毒和恶意应用。在4.x时代对Android对敏感权限还不是很敏感的时候,我就研究过给肉鸡伪造短信记录和让肉鸡给通讯录里所有(或特定)联系人发送短信的病毒。去年还研究过窃取友商App推送内容、强杀友商App进程、卸载友商App甚至让友商App被卸载后就再也不能在这台肉鸡上安装的恶意应用(或应用里的恶意功能)。

     

    转型建议:此外锁定肉鸡里的重要文件勒索用户(Android上的WannaCry?)和窃取肉鸡用户的支付密码的实现在技术上也像强奸8岁女童一样简单,只不过事后逍遥法外很难。这个转型方向只适合拿自己的手机当肉鸡玩玩,千万不要用这些技术赚钱

     

    SDK

    开发SDK本质上仍然在为Android应用开发软件,只是不直接开发Android应用。

     

    每个Android程序员工作几年后都积累了属于自己的或大或小的类库,比如封装好的LogUtils和ToastUtils等;也都或多或少研究过常用开源框架的底层原理,比如了解Picasso和EventBus等;还应该对不开源的第三方服务有自己简单的二次封装,比如我就封装了一键实现支付宝和微信支付的moudle(免费的Ping++?)。

     

    转型建议:尽管看见自己的链接出现在无数Android应用的Gradle文件的compile后面,开发了无数软件的一部分的成就感不会比开发完整的软件差。但是几乎没有老板会为了支持你开发开源软件发你工资。

     

    JavaEE

    Android程序员转型Java在基础知识方面是没什么难度的,毕竟语言相通,特性相似。同时每个Android程序员在大学时J2EE课程学得都不会很差,不过有些知识是该忘掉的,比如Hibernate已经落后于时代了,SpringMVC的全面使用才是Java后台的大势所趋。

     

    转型建议:建议不想每天改UI的刚入行不久的Android工程师转型,我有好几个学弟就是参加工作后从Android转型Java的,他们过得都不错。很多工作年限较长的Android工程师本来就是JavaEE转型来的,就别转回去了。

     

    手游

    首先考虑不放弃Java语言和Android开发习惯的情况:最合适的就是能把游戏view直接插入普通layout里的AndEngine,前几年大红大紫的Flappy Bird就是用它开发的。AndEngine的开发方式和Android别无二致,且有丰富的开源demo。不过AndEngine没有官方文档,理论学习上有一定难度。我用AndEngine开发了我的毕业设计,参加工作后也用AndEngine获得了几个奖,我珍藏着一本AndEngine的非官方文档《Android游戏开发实践指南》(全新未拆封),期待着有一天能回到2014年把它送给那个买不起它的毕业生。

     

    提到了AndEngine就不得不提国产AndEngine——OGEngine,它是基于AndEngine衍生的游戏引擎,有详细的纯中文文档和说汉语的技术支持杨城(笔名:小城),极适合开发Android TV游戏。OGEngine目前已停止更新,这个国产游戏引擎的悲剧在于推出时间太早,希望Android TV普及的时候卷土重来的OGEngine能让中国在游戏引擎方面领跑全世界。

     

    LibGDX是一个跨平台的游戏开发框架,同样使用Java作为开发语言,前文所说的AndEngine就是基于LiBGDX实现的。LibGDX最大的优点就是极强的兼容性,不仅兼容Android和iOS,还兼容Windows、Linux、Max OS X等桌面系统。极强的兼容性还为开发提供了便利——不必打开Android模拟器,直接用电脑debug你的应用。在LibGDX和Android之间相互转型都很容易,知名的Android专家宋志辉、吴佳俊等都是从LibGDX转型Android的。

     

    如果不要Java语言,那就有Cosos2d-x可供选择。《Cocos2d-x游戏开发实战精解》的作者欧桐桐(笔名:OTT)认为Android程序员一般对面向对象的知识掌握的比较全面,上手Cosos2d-x比较容易,并且Cosos2d-x是中国人维护的,文档全、资源多、教程多。OTT在得知我是和他一样的藏书人士后还特地送我一本他的大作鼓励我。

     

    转型建议:做好心理准备,国内手游行业比普通的移动互联网行业加班更疯狂,建议刚入行没多久的Android工程师为了加班费转型,不建议30岁以上的Android工程师转型。

     

    HTML5

    HTML5也是Android工程师改行的好方向,HTML5在移动互联网领域应用非常广泛,比如混合开发、手机站、小游戏、微信公众号、微信小程序等。简单的手机站和对性能要求不高小游戏直接用从懒人模板(http://www.lanrenmb.com/)上找到的资源稍微修改一下即可,这里我只说说的混合开发应用和的小游戏怎么开发。

     

    最著名的HTML5移动开发框架当属Facebook发布于2015年的React Native,这是一套跨平台、动态更新的 Javascript 框架,口号是“Learn once, write anywhere”。与之类似有同属舶来的PhoneGap等。

     

    国产的HTML5开发框架在国内也百家争鸣,常见的有HBuilder和AppCan,二者共同特点是都为了便于新手入门制作了专用的编译器。2016年,在Qcon大会上宣布开源的Weex也异军突起,来自阿里的它因为开发的软件与原生App别无二致受到很多人的青睐。

     

    开发对性能要求比较高的HTML5游戏,靠模板是不行的。2014年2月创立于北京的Egret是一套完整的HTML5游戏开发解决方案,其核心产品白鹭引擎(Egret Engine)凭借上手简便、性能强大已占据国内超七成的手机页游引擎市场份额。

     

    Egret布道师徐聪(笔名:臭臭打不死人)还送我了Egret官方教程《Egret——HTML5游戏开发指南》和Egret吉祥物。

     

    转型建议:一般来说,除非手机页游或商场,大多数用HTML5开发的Android应用就是胡闹。这条路线几乎是专为电商和小游戏行业准备的,如果公司有这方面的需求,Android程序员可以凭借平时自学的这方面技术完成任务。

     

    VR

    2015年底游戏外设王者雷蛇推出了VR游戏头显,2016年各大游戏厂商和小工作室争先恐后开发VR游戏争夺市场,开启了“中国VR元年”。虽然目前VR主要用在娱乐领域,被很多人视为玩具,但是VR所具有的价值却远远超出“玩具”的范畴。

     

    前文讨论游戏引擎的时候没说Unity-3d不是疏漏,而是要把Unity-3d放在这儿谈。Unity-3d 是Unity公司开发的一个3D游戏开发工具,近年来的新版本不断加强对VR硬件系统的支持。Android程序员转型VR不仅可以实现自己从小就想让游戏跳出四角方框的梦想,还有Unity-3d所用的C#语言本来就是嚷着“我不是Java语言”的Java语言的学习优势。

     

    转型建议:VR现在正是一片蓝海,只要自学能力够强,转型VR就像2015年在合肥买房一样明智。当然前提是你能找到愿意出钱的老板或投资人。

     

    大数据

    移动互联网时代是一个科技发达,信息流通的时代,大数据就是这个高科技时代的产物。马云曾在演讲中提到:未来的时代将不是IT时代,而是DT的时代。DT就是Data Technology(数据科技)的缩写,大数据的合理利用与否成了很多行业成败的关键。

     

    移动互联网经过这些年的发展,拿O2O和当噱头已经唬不住投资人了。Hadoop也就自然而然受到了青睐,很多每4个月“生产”一批“两年经验”的“程序员”的培训机构也问我:“Android和iOS现在不吃香了,你能帮我介绍几个Hadoop讲师吗?”

     

    转型建议:与转型Java后台一样,Android程序员转型Hadoop也具备语言相通,特性相似的优势。目前各大培训机构已经如蝇逐臭争相批量生产Hadoop程序员,如果你是因为陷入了他们培训的Android程序员造成的红海才转型的话,建议你不要转型,提升自己的竞争力才是王道。

     

    人工智能和深度学习

    前一阵子AlphaGo战胜了人类世界的围棋世界冠军柯洁,轰动了全世界。柯洁认为AlphaGo是能够打败一切的围棋上帝,这个说法我不敢苟同,毕竟它没有和“天”对弈过,但存在能“胜天半子”的人类——祁同伟。即使AlphaGo不能打败一切,也没有人有理由认为人工智能和深度学习不能成为IT届的重要发展方向。

     

    TensorFlow是谷歌基于DistBelief进行研发的第二代人工智能学习系统,具备极佳的灵活性和可延展性,在和人工智能相关的领域都有广泛的应用。TensorFlow是开源的,会大大降低深度学习在各个行业中的应用难度,有远大的发展前景。

     

    转型建议:尽管我坚信将来会T(ensor)F(low)的boys受女性欢迎程度不亚于TFboys,但TensorFlow暂时很不成熟,这个“将来”距今多久还是未知数。

     

    Android系统

    Linux作为目前大多数服务器的操作系统,学习Linux的大多数人的目的是做一个运维。然而把脑洞再开大一点的话,Android程序员精通了Linux之后可以开发一套属于自己的Android系统。《Linux大棚命令百篇》的作者吴鹏冲(笔名:Roc,和我一样也是水浒迷)和《循序渐进Linux》的作者高俊峰都送了一本自己的作品鼓励我开发属于自己的Android ORM。

     

    这张照片摄于2016年3月30日我拿着《循序渐进Linux(第二版)》回到母校的自习室里攻读想成为像高老师一样能定制自己的Android系统的Linux专家的路上(双关)

     

    转型建议:如果Android程序员准备跳槽到生产手机等搭载Android系统的硬件的厂商的话学习Linux再合适不过了,否则就只能自己刷机玩了。

     

    产品经理

    每个人都可能变成自己最讨厌的人,我也不例外。我从《人人都是产品经理》中学到了产品经理的情怀,还从《从点子到产品》中学到了产品经理的技术。还有幸赶上了今年3月《从点子到产品》的作者刘飞收徒。关于我转型产品经理失败的情况是一个发生在我和刘飞之间的“挖隋炀帝坟墓的开发商名叫杨勇”的故事:

    2016年初,我带新人,没有收刘飞(同名学弟)为徒

    2017年初,刘飞带新人,不肯收我为徒

     

    转型建议:产品经理也是技术岗位,只不过写的是给人看的需求文档。如果一个Android程序员写的代码只能让电脑看懂而不能让负责维护的程序员看懂,那么就不要转型产品经理。

     

    Android程序员转型机会虽然多,但不要因为看招聘网站上某个职业平均工资高就转型,随波逐流的弄潮儿必然会在浪潮之巅摔得好惨。培训机构常说“Android不吃香了,移动互联网的寒冬来了”来吸引人报名学习速成的Hadoop和TensorFlow,其实遭遇寒冬的不是某个行业,而是某些没有打好基础的人。


    本文首发于51CTO的IT故事汇:http://mdsa.51cto.com/art/201706/543046.htm

    展开全文
  • Android 将自己的应用改为系统应用

    万次阅读 2018-07-20 16:21:45
    &lt;div class="markdown_views"&gt; &lt;p&gt;转载请标明出处:&lt;a href="http://blog.csdn.net/xx326664162/article/details/53406933" rel="...
                    <div class="markdown_views">
                <p>转载请标明出处:<a href="http://blog.csdn.net/xx326664162/article/details/53406933" rel="nofollow" target="_blank">http://blog.csdn.net/xx326664162/article/details/53406933</a>    文章出自:<a href="http://blog.csdn.net/xx326664162" rel="nofollow" target="_blank">薛瑄的博客</a></p>
    

    所谓系统程序就是system/app目录中的程序,普通应用转换成系统程序后有稳定、减少内存(DATA)空间占用、恢复出厂设置后不会消失、修改系统时间、调用隐藏方法、系统关机重启、静默安装升级卸载应用等等等等优点,想知道怎么操作?接下来我们介绍三种方法。

    第一种:使用ADB命令将app安装在system/app目录下

    参考:android 将自己的应用改为系统应用

    这种方法的原理就是:

    1、把apk文件移动到system/app目录,
    2、.so文件移动到system/lib目录。
    3、修改相应的权限

    操作步骤:

    1. 将你的手机数据线,插上,把你的设备设置为允许usb调试
    2. 打开命令终端cmd
    3. 输入命令 adb shell
    4. 确定能进入系统
    这里写图片描述

    5. 输入命令 mount
    这里写图片描述

    6. 因为system默认是只读文件夹,所以根据上面的提示输入下面命令,使其变为可读写
    mount -o remount /dev/block/nandd /system (图)
    这里写图片描述

    再出输入 mount 查看system和上面的不一样了,说明正确

    这里写图片描述

    7. 输入 exit 退出android系统终端

    8. 解压你的apk文件,进入查看lib/armeabi文件夹下有没有 .so文件,如果没有这种库文件的话,直接跳到第10步,(因为有些apk文件是要调用动态链接库的,你不拷贝的话,就没有办法运行!会报错)如果有的话, 将这些*.so文件都拷贝到/system/lib文件夹下:

    命令:adb push libiReader_txtparser.so system/lib
    这里写图片描述

    9、拷贝完了之后呢,要给这些库文件添加权限,看看别的库文件权限是几

    chmod   644  xxxxx.so
    • 1

    这里写图片描述

    10. 将你的apk文件拷贝进入/system/app(该文件夹里存放着所以系统级别的apk),图中我是将iReader.apk拷贝过去的

    这里写图片描述

    11. 再次进入android终端 adb shell
    12. 进入system/app文件夹 cd system/app
    13. 查看其他apk的权限 ll 能看出区别

    这里写图片描述

    14. 修改iReader.apk权限使其和其他的一样 chmod 644 iReader.apk
    这里写图片描述

    15. 搞定这些之后,重启设备 reboot
    16. 看看系统里面是不是安装好了该应用,点击一下,看是否正常运行,可以的话,再检测是否无法卸载!

    第二种:借助工具把app转为系统应用(原理和方法一一样)

    转载:安卓进阶教程:怎样把应用转换成系统程序

    RE管理器转换和LINK2SD都可以实现,任选其一即可

    使用RE管理器转换

    1、首先我们把需要转换的程序在电脑上用压缩软件打开 ,看有没有lib这个目录。如果有,再把lib目录打开,直到出现以.so结尾的文件,把文件都拖出来备用。

    这里写图片描述这里写图片描述

    2、把需要转换的应用(apk文件)连同刚拖出的.so文件(如果有),放到手机内存卡,
    3、用RE管理器复制到system目录,把权限更改如图,
    4、把更改权限后的apk文件移动到system/app目录,.so文件移动到system/lib目录。
    5、完成后重启手机,应用就转换成系统程序了。

    使用LINK2SD转换

    这里写图片描述这里写图片描述

    如果感觉以上方法麻烦,也可借助工具来操作,LINK2SD、钛备份等软件都可以把普通程序转换为系统程序,以LINK2SD为例,打开LINK2SD,找到需要软件的程序,点击,再点操作,选择转换系统应用,接着会有个确认窗口,确认后,重启手机程序就转换好了。

    第三种:使用signapk打包成系统应用

    参考:
    android之使用signapk打包成系统应用,获取系统权限
    使用platform密钥来给apk文件签名的命令
    Android安全开发之通用签名风险
    关于android:sharedUserId=”android.uid.system”这个系统级权限
    安装APK 时, 提示” 共享用户权限不完整” , 不能安装成功, 如何解决?
    https://github.com/android/platform_build/tree/master/target/product/security

    为了更好地理解下面介绍的两种方法的原理,先来学习几个概念:

    Android应用签名机制

    Android系统要求安装的应用必须用数字证书进行签名后才能安装,并且签名证书的私钥由应用开发者保存。签名证书的生成也由开发者自己生成。在应用安装时会校验包名(package name)和签名,如果系统中已经存在了一个相同的包名和签名的应用,将会用新安装的应用替换旧的;如果包名相同但是签名不同,则会安装失败。

    为什么需要数字签名?

    数字签名是防止要保护的内容被篡改,用非对称加密算法。先对要保护的内容进行消息摘要,用私钥对消息摘要进行加密,生成数字签名,将数字签名和要保护的内容一起分发出去。 内容接收者用公钥对数字签名解密得到发送者给的消息摘要A,内容接收者对接收到的内容进行用相同的消息摘要算法处理得到消息摘要B,对比A和B是否相同,来判定传送的内容是否被篡改。 正常的APK文件是个ZIP压缩文件,除了应用的可执行文件、资源文件,还包括这些可执行文件、资源文件的摘要信息,数字证书的公钥信息等。并且通过这些签名信息可以确定APP和其开发者的关系。

    进行签名需要的工具有哪些?

    对apk进行签名需要用到签名证书和签名工具。Android系统要求对APP进行签名的数字证书可以由开发者自己生成。签名工具有jarsigner和signapk。jarsigner是Java本身自带的一个工具,他也可以对jar进行签名的;而signapk是专门为了Android应用程序apk进行签名的工具。二者的区别是:jarsigner工具签名时使用的是keystore签名文件,signapk工具签名时使用的是pk8,x509.pem文件。

    签名后的文件都有哪些?

    应用签名完后在应用的META-INF目录下会有三个文件:

    CERT.RSA、CERT.SF和MANIFEST.MF。

    MANIFEST.MF中保存了所有其他文件的SHA1摘要并base64编码后的值。

    CERT.SF文件 是对MANIFEST.MF文件中的每项中的每行加上“rn”后,再次SHA1摘要并base64编码后的值(这是为了防止通过篡改文件和其在MANIFEST.MF中对应的SHA1摘要值来篡改APK,要对MANIFEST的内容再进行一次数字摘要)。

    CERT.RSA 文件:包含了签名证书的公钥信息和发布机构信息。

    对安装包的校验过程在源码的frameworks/base/core/java/android/content/pm/PackageParser.java类中可以看到

    什么是通用签名?

    搭建好Android开发环境后(使用Eclipse或Android Studio),对APK签名的默认密钥存在debug.keystore文件中。在linux和Mac上debug.keystore文件位置是在~/.android路径下,在windows目录下文件位置是C:\user\用户名.android路径下。

    除了debug.keystore外,在AOSP发布的Android源码中,还有以下几个证书是公开的,任何人都可以获取,在源码的build/target/product/security目录中:

    这里写图片描述

    这几个证书的作用:

    testkey

    Generic default key for packages that do not otherwise specify a key.

    platform

    Test key for packages that are part of the core platform.

    shared

    Test key for things that are shared in the home/contacts process.

    media

    Test key for packages that are part of the media/download system.

    verity

    Test Key for verifiedboot system imagein Android Lollipop. Sign boot.img,sign verity metadata in system.img.

    通用签名风险:

    (1)如果攻击者的应用包名与目标应用相同,又使用了相同的密钥对应用进行签名,攻击者的应用就可以替换掉目标应用;

    (2)另外目标应用的自定义权限android:protectionlevel为“signature”或者“signatureOrSystem”时,保护就形同虚设;

    (3)如果设备使用的是第三方ROM,而第三方ROM的系统也是用AOSP默认的签名,那么使用如果使用系统级签名文件签名过的应用,权限就得到了提升。

    具体的实现方法:

    第一种是需要在Android系统源码的环境下用make来编译:

    1. 在应用程序的AndroidManifest.xml中的manifest节点中加入android:sharedUserId=”android.uid.system”这个属性。
    2. 修改Android.mk文件,加入LOCAL_CERTIFICATE := platform这一行
    3. 使用mm命令来编译,生成的apk就有修改系统时间的权限了。

    第二种:

    下面着重介绍一个这个方法:

    1. 加入android:sharedUserId=”android.uid.system”这个属性。

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
              package="com.example.jant.addview"
              android:sharedUserId="android.uid.system" >
        <application
           ...(省略若干代码)
        </application>
    
    </manifest>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    2. 使用自己的签名文件,生成apk

    3. 使用通用签名来重新给apk文件签名。

    3.1 .准备好platform.pk8、platform.x509.pem和签名工具signapk.jar(3个文件的下载地址),还有自己的apk,放在同一个文件夹下。

    3.2 在cmd下进入到该文件夹后,使用如下命令:
    这里写图片描述

    3.3 回车后我们的文件夹下已经多了一个new.apk文件了,这就将我们的应用打包成系统应用


    你也可以在github中去下载,但是下载的是SignApk.java,需要进行一些处理,如下

    1.1.进入\build\target\product\security,找到【platform.pk8】和【platform.x509.pem】系统密钥。
    1.2.进入\build\tools\signapk找到SignApk.java,运行 javac编译成SignApk.class
    1.3.执行命令java com.android.signapk.SignApk platform.x509.pem platform.pk8 input.apk output.apk

    最后解释一下原理

    首先加入android:sharedUserId=”android.uid.system”这个属性。通过Shared User id,拥有同一个User id的多个APK可以配置成运行在同一个进程中。那么把程序的UID配成android.uid.system,也就是要让程序运行在系统进程中,也就是系统应用。

    只是加入UID还不够,如果这时候安装APK的话发现无法安装,提示签名不符,原因是程序想要运行在系统进程中还要有目标系统的platform key,就是上面第二个方法提到的platform.pk8和platform.x509.pem两个文件。用这两个key签名后apk才真正可以放入系统进程中。第一个方法中加入LOCAL_CERTIFICATE := platform其实就是用这两个key来签名。

    这也有一个问题,就是这样生成的程序只有在原始的Android系统或者是自己编译的系统中才可以用,因为这样的系统才可以拿到platform.pk8和platform.x509.pem两个文件。要是别家公司做的Android上连安装都安装不了。试试原始的Android中的key来签名,程序在模拟器上运行OK,不过放到小米四上安装uibl,如下图,这样也是保护了系统的安全。

    这里写图片描述

    最后还说下,这个android:sharedUserId属性不只可以把apk放到系统进程中,也可以配置多个APK运行在一个进程中,这样可以共享数据,应该会很有用的。
    你在Manifest.xml里声明使用了shareuserid 或者一些特殊permission,比如你shareuserid到uid.system,就必须使用系统platform签名来签你的apk,否则是不能安装的,同理share到其他用户id或者其他process上也是得用跟那个process运行的apk一样的签名
    一般签名肯定是厂商私有的,你肯定是没办法了,除非机器烧的是开发版本(eng)

    检验app是否已经是系统应用

    查看应用的进程属性,如果是system用户组,说明已经是系统应用。

    这里写图片描述


    展开全文
  • Android程序调试方法介绍

    千次阅读 多人点赞 2019-02-21 11:48:09
    一般的Android开发人员最爱的调试法,使用简便,仅需一行代码,轻松打印: Toast.makeText(MainActivity.this, &amp;quot;Toast调试&amp;quot;, Toast.LENGTH_SHORT).show(); 方便是挺方便的,不过有一点要...
  • 我作为一个普通的Android程序员,由于需求原因被公司安排做小程序开发了,前前后后研究小程序也有两个月左右了,也完成了公司的一个小工具,算是入门了。前面我也在公众号发布过小程序的学习文章。 接下来我将计划...
  • 第一个Android程序

    千次阅读 2018-09-01 16:28:23
    下面开始创建第一个Android应用程序。 首先,启动Android Studio,如下图所示,进入欢迎页面 可以通过该页面创建新的Android Studio工程,打开已经存在的Android工程。 在Configure菜单下可以设置Android SDK,...
  • Android开发之一个简单实用相机

    万次阅读 2020-03-16 00:41:47
    这一个简单实用的小程序包含了短信,电话,定位等多种功能; 但其原理十分简单,界面还有待优化一下;让其更加美观! 界面设计为: 代码: &lt;?xml version="1.0" encoding="utf-8"?&...
  • Android项目实战——一个简单的记事本程序

    万次阅读 多人点赞 2018-10-21 10:44:20
    因为自己刚看完第一行代码,就想做一个小小的项目来巩固一下自己的知识,顺便检验一下自己的学习成果。 运行界面如图: 相信大家都已经看出来了,这个app分为两个activity,MainActivity中列出笔记的title,用户...
  • 安卓权限详解

    万次阅读 2017-11-08 11:12:28
    Android的设计中,资源的访问或者网络连接,要得到这些服务都需要声明其...android.permission.EXPAND_STATUS_BAR允许一个程序扩展收缩在状态栏,android开发网提示应该是一个类似Windows Mobile中的托盘程序 and
  • Android之权限(permission)大全

    万次阅读 2018-10-17 18:15:55
    个人开发的微信小程序,目前功能是书籍推荐,后续会完善一些新功能,希望大家多多支持!   1.android.permission.WRITE_USER_DICTIONARY 允许应用程序向用户词典中写入新词 2.android.permission.WRITE_SYNC_...
  • import eclipes ADT项目工程后,报如下错误: 程序android.support.v4.app不存在 错误原因:缺少android.support.v4.app 依赖包 解决方法: 1、File->Project Structure->app->Dependences->Add Library ...
  • 程序android.support.annotation不存在

    万次阅读 多人点赞 2016-08-18 14:19:55
    最近开始把开发Android应用程序的工具从eclipse逐渐过渡到Android Studio上来,万事开头难!自然也遇到了很多问题,导入的工程出现很多错误,导致编译不通过。 问题1:程序android.support.annotation不存在 这是...
  • uses-permission权限列表

    万次阅读 2011-03-11 13:49:00
    CHECKIN_PROPERTIES 允许读写访问”properties”表在checkin数据库中,改值可以修改上传 android.permission.ACCESS_COARSE_LOCATION 允许一个程序访问CellID或WiFi来获取粗略的位置 android....
  • Hbuilder 5+ 基本权限设置

    万次阅读 2015-01-16 14:21:08
    5 API分模块封装调用了系统各种原生能力,而部分能力需要使用到Android的permissions,以下列出了各模块(或具体API)使用的的权限: 基础权限 5 App必须使用的到最小权限集 API 权限 说明 ...
  • Android常用权限permission列表摘录

    万次阅读 2013-01-10 14:26:36
    一个Android应用程序需要权限才能调用某些android系统的功能;一个android应用也可能被其他应用调用,因此也需要声明调用自身所需要的权限。除了平时常用的权限记得比较熟悉,还有很多的权限一时需要用到却有想不...
  • Android程序出现停止运行解决方法

    万次阅读 2018-04-29 23:22:04
    Eclipse真机运行程序时出现安卓程序停止运行检查了一下,发现要先初始化页面再初始化按钮
  • Android Studio新建一个HelloWorld 程序(App) 新建 或者直接启动程序(注:如果已有程序,此方法会直接打开最近一次关闭从程序) 更改App名 选择App运行平台 选择模板 更改主视图...
  • 参考了这篇博客http://blog.csdn.net/wu_wxc/article/details/46846337 首先,在AndroidManifest.xml中添加网络访问权限,节点下加上 ... ...import android.support.v7.app.AppCompatActivity;
1 2 3 4 5 ... 20
收藏数 714,378
精华内容 285,751
关键字:

android程序