android基础架构

只看该作者 · 2013-9-30 10:34

只看该作者 · 2013-9-30 10:36

本帖最后由心愿wish 于 2013-9-30 10:37 编辑

Android 框架简介
这里简单的介绍了Android的java环境基础，在后面一节中会结合具体的实例来理解这一节的内容。
一、Dalvik虚拟机
Dalvik是Android的程序的java虚拟机，代码在dalvik/下，
./
|-- Android.mk
|-- CleanSpec.mk
|-- MODULE_LICENSE_APACHE2
|-- NOTICE

分析的应用程序我们也奉行拿来主义:froyo/development/samples/HelloActivity
./
|-- Android.mk
|-- AndroidManifest.xml
|-- res
|-- src
`-- tests
其他的就多说了，看代码

01

/*

02	* Copyright (C) 2007 The Android Open Source Project

03

*

04	* Licensed under the Apache License, Version 2.0 (the "License");

05	* you may not use this file except in compliance with the License.

06	* You may obtain a copy of the License at

07

*

08	* http://www.apache.org/licenses/LICENSE-2.0

09

*

10	* Unless required by applicable law or agreed to in writing, software

11	* distributed under the License is distributed on an "AS IS" BASIS,

12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

13	* See the License for the specific language governing permissions and

14	* limitations under the License.

15

*/

16	package com.example.Android.helloactivity;

17	import Android.app.Activity;

18	import Android.os.Bundle;

19

/**

20	* A minimal "Hello, World!" application.

21

*/

22	public class HelloActivity extends Activity {

23	public HelloActivity() {

24

}

25

/**

26	* Called with the activity is first created.

27

*/

28

@Override

29	public void onCreate(Bundle savedInstanceState) {

30	super.onCreate(savedInstanceState);

31	// Set the layout for this activity. You can find it

32	// in res/layout/hello_activity.xml

33	setContentView(R.layout.hello_activity);

34

}

35

}

每一个写过Android程序的人都应该是从这个代码起步的吧？那好，那么我们研究android框架也从这里启航。
首先是

1	import Android.app.Activity;

2	import Android.os.Bundle;

记住，我们这里不是讲JAVA，我们要讲的是Android.app.Activity，回顾上节的内容，android的JAVA框架代码放在froyo/frameworks/base/，

其中Activity的代码放在框架代码的core/java/Android/app/Activity.java，大概看一下

01	public class Activity extends ContextThemeWrapper

02	implements LayoutInflater.Factory,

03	Window.Callback, KeyEvent.Callback,

04	OnCreateContextMenuListener, ComponentCallbacks {

05	private static final String TAG = "Activity";

06	/** Standard activity result: operation canceled. */

07	public static final int RESULT_CANCELED = 0;

08	/** Standard activity result: operation succeeded. */

09	public static final int RESULT_OK = -1;

10	/** Start of user-defined activity results. */

11	public static final int RESULT_FIRST_USER = 1;

12	private static long sInstanceCount = 0;

同样的Bundle的代码core/java/Android/os/Bundle.java

1	public final class Bundle implements Parcelable, Cloneable {

2	private static final String LOG_TAG = "Bundle";

3	public static final Bundle EMPTY;

呵呵，其实写多应用程序，然后看看这些代码，会有更加豁然开朗的感觉，所以列出以上目录给大家参考，所有的java框架代码都在那个目录下，到这里今天要讨论的第一个问题就到这里了。
我所在的公司是网络设备供应商，其实和Android本身不搭边，android只是平时的爱好而已，所以很多地方如果写错了敬请原谅，当然也计划去做做android系统开发，例如驱动或者是框架开发，这是后话。
======================== 第三节 ========================
上节讲到了JAVA框架代码和应用程序的关系，那么框架代码和驱动层是怎么联系的呢？这就是这一节的内容：JNI
java使用一种叫做jni的技术来支持对C/C++代码的调用，在anroid中jni的代码放在froyo/frameworks/base/core/jni下，当然在java框架代码的目录下还有其他地方也多多少少放了jni代码，大家可以打开源码来看看。
整体关系如下图：

| java应用程序
--------------------------------------- Android系统api
| java框架
｜本地接口声明
--------------------------------------
| JNI
--------------------------------------
| C/C++代码

只看该作者 · 2013-9-30 10:39

本帖最后由心愿wish 于 2013-9-30 10:42 编辑

继续拿来主义，C/C++中调试用printf，内核调试用printk，呵呵，Android调试用log，那么我们就分析log的实现。
log的java代码froyo/frameworks/base/core/java/Android/util/Log.java，

001

/**

002	* Copyright (C) 2006 The Android Open Source Project

003

*

004	* Licensed under the Apache License, Version 2.0 (the "License");

005	* you may not use this file except in compliance with the License.

006	* You may obtain a copy of the License at

007

*

008	* http://www.apache.org/licenses/LICENSE-2.0

009

*

010	* Unless required by applicable law or agreed to in writing, software

011	* distributed under the License is distributed on an "AS IS" BASIS,

012	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

013	* See the License for the specific language governing permissions and

014	* limitations under the License.

015

*/

016	package Android.util;

017	import com.Android.internal.os.RuntimeInit;

018	import java.io.PrintWriter;

019	import java.io.StringWriter;

020

/**

021	* API for sending log output.

022

*

023	* <p>Generally, use the Log.v() Log.d() Log.i() Log.w() and Log.e()

024	* methods.

025

*

026	* <p>The order in terms of verbosity, from least to most is

027	* ERROR, WARN, INFO, DEBUG, VERBOSE. Verbose should never be compiled

028	* into an application except during development. Debug logs are compiled

029	* in but stripped at runtime. Error, warning and info logs are always kept.

030

*

031	* <p><b>Tip:</b> A good convention is to declare a <code>TAG</code> constant

032	* in your class:

033

*

034	* <pre>private static final String TAG = "MyActivity";</pre>

035

*

036	* and use that in subsequent calls to the log methods.

037

* </p>

038

*

039	* <p><b>Tip:</b> Don't forget that when you make a call like

040	* <pre>Log.v(TAG, "index=" + i);</pre>

041	* that when you're building the string to pass into Log.d, the compiler uses a

042	* StringBuilder and at least three allocations occur: the StringBuilder

043	* itself, the buffer, and the String object. Realistically, there is also

044	* another buffer allocation and copy, and even more pressure on the gc.

045	* That means that if your log message is filtered out, you might be doing

046	* significant work and incurring significant overhead.

047

*/

048	public final class Log {

049

/**

050	* Priority constant for the println method; use Log.v.

051

*/

052	public static final int VERBOSE = 2;

053

/**

054	* Priority constant for the println method; use Log.d.

055

*/

056	public static final int DEBUG = 3;

057

/**

058	* Priority constant for the println method; use Log.i.

059

*/

060	public static final int INFO = 4;

061

/**

062	* Priority constant for the println method; use Log.w.

063

*/

064	public static final int WARN = 5;

065

/**

066	* Priority constant for the println method; use Log.e.

067

*/

068	public static final int ERROR = 6;

069

/**

070	* Priority constant for the println method.

071

*/

072	public static final int ASSERT = 7;

073

/**

074	* Exception class used to capture a stack trace in {@ link #wtf()}.

075

*/

076	private static class TerribleFailure extends Exception {

077	TerribleFailure(String msg, Throwable cause) { super(msg, cause); }

078

}

079	private Log() {

080

}

081

/**

082	* Send a {@link #VERBOSE} log message.

083	* @param tag Used to identify the source of a log message. It usually identifies

084	* the class or activity where the log call occurs.

085	* @param msg The message you would like logged.

086

*/

087	public static int v(String tag, String msg) {

088	return println_native(LOG_ID_MAIN, VERBOSE, tag, msg);

089

}

090

/**

091	* Send a {@link #VERBOSE} log message and log the exception.

092	* @param tag Used to identify the source of a log message. It usually identifies

093	* the class or activity where the log call occurs.

094	* @param msg The message you would like logged.

095	* @param tr An exception to log

096

*/

097	public static int v(String tag, String msg, Throwable tr) {

098	return println_native(LOG_ID_MAIN, VERBOSE, tag, msg + '/n' + getStackTraceString(tr));

099

}

100

/**

101	* Send a {@link #DEBUG} log message.

102	* @param tag Used to identify the source of a log message. It usually identifies

103	* the class or activity where the log call occurs.

104	* @param msg The message you would like logged.

105

*/

106	public static int d(String tag, String msg) {

107	return println_native(LOG_ID_MAIN, DEBUG, tag, msg);

108

}

109

/**

110	* Send a {@link #DEBUG} log message and log the exception.

111	* @param tag Used to identify the source of a log message. It usually identifies

112	* the class or activity where the log call occurs.

113	* @param msg The message you would like logged.

114	* @param tr An exception to log

115

*/

116	public static int d(String tag, String msg, Throwable tr) {

117	return println_native(LOG_ID_MAIN, DEBUG, tag, msg + '/n' + getStackTraceString(tr));

118

}

119

/**

120	* Send an {@link #INFO} log message.

121	* @param tag Used to identify the source of a log message. It usually identifies

122	* the class or activity where the log call occurs.

123	* @param msg The message you would like logged.

124

*/

125	public static int i(String tag, String msg) {

126	return println_native(LOG_ID_MAIN, INFO, tag, msg);

127

}

128

/**

129	* Send a {@link #INFO} log message and log the exception.

130	* @param tag Used to identify the source of a log message. It usually identifies

131	* the class or activity where the log call occurs.

132	* @param msg The message you would like logged.

133	* @param tr An exception to log

134

*/

135	public static int i(String tag, String msg, Throwable tr) {

136	return println_native(LOG_ID_MAIN, INFO, tag, msg + '/n' + getStackTraceString(tr));

137

}

138

/**

139	* Send a {@link #WARN} log message.

140	* @param tag Used to identify the source of a log message. It usually identifies

141	* the class or activity where the log call occurs.

142	* @param msg The message you would like logged.

143

*/

144	public static int w(String tag, String msg) {

145	return println_native(LOG_ID_MAIN, WARN, tag, msg);

146

}

147

/**

148	* Send a {@link #WARN} log message and log the exception.

149	* @param tag Used to identify the source of a log message. It usually identifies

150	* the class or activity where the log call occurs.

151	* @param msg The message you would like logged.

152	* @param tr An exception to log

153

*/

154	public static int w(String tag, String msg, Throwable tr) {

155	return println_native(LOG_ID_MAIN, WARN, tag, msg + '/n' + getStackTraceString(tr));

156

}

157

/**

只看该作者 · 2013-9-30 10:39

本帖最后由心愿wish 于 2013-9-30 10:41 编辑

158	* Checks to see whether or not a log for the specified tag is loggable at the specified level.

159

*

160	* The default level of any tag is set to INFO. This means that any level above and including

161	* INFO will be logged. Before you make any calls to a logging method you should check to see

162	* if your tag should be logged. You can change the default level by setting a system property:

163	* 'setprop log.tag.<YOUR_LOG_TAG> <LEVEL>'

164	* Where level is either VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT, or SUPPRESS. SUPPRESS will

165	* turn off all logging for your tag. You can also create a local.prop file that with the

166	* following in it:

167	* 'log.tag.<YOUR_LOG_TAG>=<LEVEL>'

168	* and place that in /data/local.prop.

169

*

170	* @param tag The tag to check.

171	* @param level The level to check.

172	* Whether or not that this is allowed to be logged.

173	* @throws IllegalArgumentException is thrown if the tag.length() > 23.

174

*/

175	public static native boolean isLoggable(String tag, int level);

176

/**

177	* Send a { #WARN} log message and log the exception.

178	* @param tag Used to identify the source of a log message. It usually identifies

179	* the class or activity where the log call occurs.

180	* @param tr An exception to log

181

*/

182	public static int w(String tag, Throwable tr) {

183	return println_native(LOG_ID_MAIN, WARN, tag, getStackTraceString(tr));

184

}

185

/**

186	* Send an {@link #ERROR} log message.

187	* @param tag Used to identify the source of a log message. It usually identifies

188	* the class or activity where the log call occurs.

189	* @param msg The message you would like logged.

190

*/

191	public static int e(String tag, String msg) {

192	return println_native(LOG_ID_MAIN, ERROR, tag, msg);

193

}

194

/**

195	* Send a {@link #ERROR} log message and log the exception.

196	* @param tag Used to identify the source of a log message. It usually identifies

197	* the class or activity where the log call occurs.

198	* @param msg The message you would like logged.

199	* @param tr An exception to log

200

*/

201	public static int e(String tag, String msg, Throwable tr) {

202	return println_native(LOG_ID_MAIN, ERROR, tag, msg + '/n' + getStackTraceString(tr));

203

}

204

/**

205	* What a Terrible Failure: Report a condition that should never happen.

206	* The error will always be logged at level ASSERT with the call stack.

207	* Depending on system configuration, a report may be added to the

208	* {@link Android.os.DropBoxManager} and/or the process may be terminated

209	* immediately with an error dialog.

210	* @param tag Used to identify the source of a log message.

211	* @param msg The message you would like logged.

212

*/

213	public static int wtf(String tag, String msg) {

214	return wtf(tag, msg, null);

215

}

216

/**

217	* What a Terrible Failure: Report an exception that should never happen.

218	* Similar to {@link #wtf(String, String)}, with an exception to log.

219	* @param tag Used to identify the source of a log message.

220	* @param tr An exception to log.

221

*/

222	public static int wtf(String tag, Throwable tr) {

223	return wtf(tag, tr.getMessage(), tr);

224

}

225

/**

226	* What a Terrible Failure: Report an exception that should never happen.

227	* Similar to {@link #wtf(String, Throwable)}, with a message as well.

228	* @param tag Used to identify the source of a log message.

229	* @param msg The message you would like logged.

230	* @param tr An exception to log. May be null.

231

*/

232	public static int wtf(String tag, String msg, Throwable tr) {

233	tr = new TerribleFailure(msg, tr);

234	int bytes = println_native(LOG_ID_MAIN, ASSERT, tag, getStackTraceString(tr));

235	RuntimeInit.wtf(tag, tr);

236	return bytes;

237

}

238

/**

239	* Handy function to get a loggable stack trace from a Throwable

240	* @param tr An exception to log

241

*/

242	public static String getStackTraceString(Throwable tr) {

243	if (tr == null) {

244	return "";

245

}

246	StringWriter sw = new StringWriter();

247	PrintWriter pw = new PrintWriter(sw);

248	tr.printStackTrace(pw);

249	return sw.toString();

250

}

251

/**

252	* Low-level logging call.

253	* @param priority The priority/type of this log message

254	* @param tag Used to identify the source of a log message. It usually identifies

255	* the class or activity where the log call occurs.

256	* @param msg The message you would like logged.

257	* @return The number of bytes written.

258

*/

259	public static int println(int priority, String tag, String msg) {

260	return println_native(LOG_ID_MAIN, priority, tag, msg);

261

}

262	/** @hide */ public static final int LOG_ID_MAIN = 0;

263	/** @hide */ public static final int LOG_ID_RADIO = 1;

264	/** @hide */ public static final int LOG_ID_EVENTS = 2;

265	/** @hide */ public static final int LOG_ID_SYSTEM = 3;

266	/** @hide */ public static native int println_native(int bufID,

267	int priority, String tag, String msg);

268

}

我们看到所有代码都是调用public static native int println_native(int bufID,
int priority, String tag, String msg);来实现输出的，这个函数的实现就是C++，调用的方式就是JNI
我们看一下对应的jni代码froyo/frameworks/base/core/jni/Android_util_Log.cpp，最终调用的输出函数是

01

/*

02	* In class Android.util.Log:

03	* public static native int println_native(int buffer, int priority, String tag, String msg)

04

*/

05	static jint Android_util_Log_println_native(JNIEnv* env, jobject clazz,

06	jint bufID, jint priority, jstring tagObj, jstring msgObj)

07

{

08	const char* tag = NULL;

09	const char* msg = NULL;

10	if (msgObj == NULL) {

11	jclass npeClazz;

12	npeClazz = env->FindClass("java/lang/NullPointerException");

13	assert(npeClazz != NULL);

14	env->ThrowNew(npeClazz, "println needs a message");

15	return -1;

16

}

17	if (bufID < 0 \|\| bufID >= LOG_ID_MAX) {

18	jclass npeClazz;

19	npeClazz = env->FindClass("java/lang/NullPointerException");

20	assert(npeClazz != NULL);

21	env->ThrowNew(npeClazz, "bad bufID");

22	return -1;

23

}

24	if (tagObj != NULL)

25	tag = env->GetStringUTFChars(tagObj, NULL);

26	msg = env->GetStringUTFChars(msgObj, NULL);

27	int res = __Android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);

28	if (tag != NULL)

29	env->ReleaseStringUTFChars(tagObj, tag);

30	env->ReleaseStringUTFChars(msgObj, msg);

31	return res;

32

}

当然我们发现最终输出是

1	int res = __Android_log_buf_write(bufID, (android_LogPriority)priority, tag, msg);

用力grep了一下代码，结果如下

1	./system/core/include/cutils/log.h:int __Android_log_buf_write(int bufID, int prio, const char tag, const char text);

2	./system/core/liblog/logd_write.c:int __Android_log_buf_write(int bufID, int prio, const char tag, const char msg)

3	./system/core/liblog/logd_write.c: return __Android_log_buf_write(bufID, prio, tag, buf);

这个就是和Android专用驱动进行通信的方式，这个分析下去就有点深了，后面分析。
以上三个小节分析了Android的JAVA环境，我这里都是简单的抛砖引玉，希望能给大家一点大体的指引，其他修行靠大家了，能成为是一个android程序员是多么幸福的事情，各位已经在幸福中了，我什么时候也可以幸福一把？？