androidlogv

❶ 如何在android 系统 C/C++ 层中添加 log 信息

#include 并且在 函数中添加如下 log 输出信息(如蓝色字体显示)：status_t MediaRecorder::setCamera(const sp& camera){LOGV("setCamera(%p)", camera.get()); if(mMediaRecorder == NULL) { LOGE("media recorder is not initialized yet"); return INVALID_OPERATION;}if (!(mCurrentState & MEDIA_RECORDER_IDLE)) { LOGE("setCamera called in an invalid state(%d)", mCurrentState); return INVALID_OPERATION;}status_t ret = mMediaRecorder->setCamera(camera); if (OK != ret) { LOGV("setCamera failed: %d", ret); mCurrentState = MEDIA_RECORDER_ERROR; 并且宏定义一下原始的 log 输出函数 __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG, __VA_ARGS__); 或者__android_log_write(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__);这样就不需要在打 log 的时候敲入那么多字符了宏定义如下：#define LOG_TAG "MediaRecorder"#define LOG(...) __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG, __VA_ARGS__) 当然，你也可以只打印点字符信息LOG("InitFbImage");Log 信息查看：所有的 log 信息都可以通过控制台输出。

❷ android bluetooth hid协议的开发求助

Android Bluetooth HID实现详解

Android 关于蓝牙的部分使用的是BlueZ协议栈。但是直到目前2.3.3都没有扩展HID的profile，只是实现了最基本的Handset和d2dp的profile，所以我们的工作涉及到从应用到jni三层的修改，具体修改文件如图所示，绿色表示新建的类，橙色表示修改的类。

一. 本地层

路径：framework/base/core/jni/

参照android_server_BluetoothA2dpService.cpp新建android_server_bluetoothHidServer.cpp。该类中主要是通过dbus对bluez协议栈的访问，dbus 的通用方法都在android_bluetooth_common.cpp中实现，我们做的仅仅是通过dbus_func_args_async调用到bluez提供的input接口。

主要实现以下两个方法函数：

static jboolean connectSinkNative(JNIEnv *env, jobject object, jstring path) {

#ifdef HAVE_BLUETOOTH

LOGV(__FUNCTION__);

if (nat) {

const char *c_path = env->GetStringUTFChars(path, NULL);

bool ret = dbus_func_args_async(env, nat->conn, -1, NULL, NULL, nat,

c_path, "org.bluez.Input", "Connect",

DBUS_TYPE_INVALID);

env->ReleaseStringUTFChars(path, c_path);

return ret ? JNI_TRUE : JNI_FALSE;

}

#endif

return JNI_FALSE;

}

static jboolean disconnectSinkNative(JNIEnv *env, jobject object,

jstring path) {

#ifdef HAVE_BLUETOOTH

LOGV(__FUNCTION__);

if (nat) {

const char *c_path = env->GetStringUTFChars(path, NULL);

bool ret = dbus_func_args_async(env, nat->conn, -1, NULL, NULL, nat,

c_path, "org.bluez.Input", "Disconnect",

DBUS_TYPE_INVALID);

env->ReleaseStringUTFChars(path, c_path);

return ret ? JNI_TRUE : JNI_FALSE;

}

#endif

return JNI_FALSE;

}

这里要注意将该文件添加到AndroidRuntime.cpp和Android.mk中，否则不会编译到动态库中。

此部分编译后最终生成libandroid_runtime.so并替换到system/libs下

二．Framework的java部分

路径framework/base/java/android/server/中添加BluetoothHidService.java文件

路径framework/base/java/android/bluetooth/中添加BluetoothHid.java和IBluetoothHid.aidl文件。

interface IBluetoothHid {

boolean connect(in BluetoothDevice device);

boolean disconnect(in BluetoothDevice device);

int getState(in BluetoothDevice device);

boolean setPriority(in BluetoothDevice device, int priority);

int getPriority(in BluetoothDevice device);

}

BluetoothHid.java中主要的两个方法connect和disconnect间接地通过aidl访问BluetoothHidService。这里主要是实现跨进程并为上层提供可直接访问的方法。

由此framework的主要部分打包生成framework.Jar并最终部署到system/framework里。

三．应用（Settings.apk）

最后需要修改应用部分，应用部分的修改点比较分散，不想框架层那样整块模仿A2DP的样子那么方便，但也不是说jni部分有多么容易。反而对于我这种对C语言不熟悉的人来说，修改jni是最头疼得事了。好在蓝牙HID这部分框架层的修改都是整块进行的，理解上还算比价容易。

总的来说在Settings.apk中要修改的文件主要是这么几个：

LocalBluetoothProfileManager.java这里主要提供一个HID的profile以便应用层访问。建一个HIDProfile的class调用framework中的BluetoothHID。实际上就是通过bender机制调用了BluetoothHidService。

CashedBluetoothDevice中添加显示蓝牙键盘的图标，BluetoothPairingDialog中则需要添加一段蓝牙配对验证处理的代码，我是参照i9000中先弹出一个随机数，然后在键盘中敲入相同的随机数即配对成功，具体实现如下：

// HID

if (isDeviceKeyboard(mDevice)) {

String pin = String.format("%06d", Long.valueOf(Math

.abs(new Random().nextLong() % 1000000L)));

mPairingView.setVisibility(View.GONE);

messageView.setText(getString(

R.string.bluetooth_enter_keyboard_pin_msg, pin, name));

byte[] bytePin = BluetoothDevice.convertPinToBytes(pin);

if (bytePin != null) {

mDevice.setPin(bytePin);

}

}

……

}

转载

❸ Android系统怎么利用利用Java反射技术阻止通过按钮关闭对话框（AlertDialog）

众所周知，AlertDialog类用于显示对话框。关于AlertDialog的基本用法在这里就不详细介绍了，网上有很多，读者可以自己搜索。那么本文要介绍的是如何随心所欲地控制AlertDialog。
现在我们来看看第一个需求：如果某个应用需要弹出一个对话框。当单击“确定“按钮时完成某些工作，如果这些工作失败，对话框不能关闭。而当成功完成工作后，则关闭对话框。当然，无论何程度情况，单击“取消”按钮都会关闭对话框。
这个需求并不复杂，也并不过分（虽然我们可以自己弄个Activity来完成这个工作，也可在View上自己放按钮，但这显示有些大炮打蚊子了，如果对话框上只有一行文本，费这么多劲太不值了）。但使用过AlertDialog的读者都知道，无论单击的哪个按钮，无论按钮单击事件的执行情况如何，对话框是肯定要关闭的。也就是说，用户无法控制对话框的关闭动作。实际上，关闭对话框的动作已经在Android SDK写死了，并且未给使用者留有任何接口。但我的座右铭是“宇宙中没有什么是不能控制的”。
既然要控制对放框的关闭行为，首先就得分析是哪些类、哪些代码使这个对话框关闭的。进入AlertDialog类的源代码。在AlertDialog中只定义了一个变量：mAlert。这个变量是AlertController类型。AlertController类是Android的内部类，在com.android.internal.app包中，无法通过普通的方式访问。也无法在Eclipse中通过按Ctrl键跟踪进源代码。但可以直接在Android源代码中找到AlertController.java。我们再回到AlertDialog类中。AlertDialog类实际上只是一个架子。象设置按钮、设置标题等工作都是由AlertController类完成的。因此，AlertController类才是关键。
找到AlertController.java文件。打开后不要感到头晕哦，这个文件中的代码是很多地。不过这么多代码对本文的主题也没什么用处。下面就找一下控制按钮的代码。
在AlertController类的开头就会看到如下的代码： View.OnClickListener mButtonHandler = new View.OnClickListener() {
public void onClick(View v) {
Message m = null ;
if (v == mButtonPositive && mButtonPositiveMessage != null ) {
m = Message.obtain(mButtonPositiveMessage);
} else if (v == mButtonNegative && mButtonNegativeMessage != null ) {
m = Message.obtain(mButtonNegativeMessage);
} else if (v == mButtonNeutral && mButtonNeutralMessage != null ) {
m = Message.obtain(mButtonNeutralMessage);
}
if (m != null ) {
m.sendToTarget();
} // Post a message so we dismiss after the above handlers are executed
mHandler.obtainMessage(ButtonHandler.MSG_DISMISS_DIALOG, mDialogInterface)
.sendToTarget();
}
};
从这段代码中可以猜出来，前几行代码用来触发对话框中的三个按钮（ Positive 、 Negative 和 Neutral ）的单击事件，而最后的代码则用来关闭对话框（因为我们发现了 MSG_DISMISS_DIALOG 、猜出来的）。
mHandler.obtainMessage(ButtonHandler.MSG_DISMISS_DIALOG, mDialogInterface)
.sendToTarget(); 上面的代码并不是直接来关闭对话框的，而是通过一个 Handler 来处理，代码如下：
private static final class ButtonHandler extends Handler {
// Button clicks have Message.what as the BUTTON{1,2,3} constant
private static final int MSG_DISMISS_DIALOG = 1 ;

private WeakReference < DialogInterface > mDialog; public ButtonHandler(DialogInterface dialog) {
mDialog = new WeakReference < DialogInterface > (dialog);
} @Override
public void handleMessage(Message msg) {
switch (msg.what) {

case DialogInterface.BUTTON_POSITIVE:
case DialogInterface.BUTTON_NEGATIVE:
case DialogInterface.BUTTON_NEUTRAL:
((DialogInterface.OnClickListener) msg.obj).onClick(mDialog.get(), msg.what);
break ;

case MSG_DISMISS_DIALOG:
((DialogInterface) msg.obj).dismiss();
}
}
}
从上面代码的最后可以找到 ((DialogInterface) msg.obj).dismiss();。现在看了这么多源代码，我们来总结一下对话框按钮单击事件的处理过程。在AlertController处理对话框按钮时会为每一个按钮添加一个onclick事件。而这个事件类的对象实例就是上面的mButtonHandler。在这个单击事件中首先会通过发送消息的方式调用为按钮设置的单击事件（也就是通过setPositiveButton等方法的第二个参数设置的单击事件），在触发完按钮的单击事件后，会通过发送消息的方式调用dismiss方法来关闭对话框。而在AlertController类中定义了一个全局的mHandler变量。在AlertController类中通过ButtonHandler类来对象来为mHandler赋值。因此，我们只要使用我们自己Handler对象替换ButtonHandler就可以阻止调用dismiss方法来关闭对话框。下面先在自己的程序中建立一个新的ButtonHandler类（也可叫其他的名）。
class ButtonHandler extends Handler
{ private WeakReference < DialogInterface > mDialog; public ButtonHandler(DialogInterface dialog)
{
mDialog = new WeakReference < DialogInterface > (dialog);
} @Override
public void handleMessage(Message msg)
{
switch (msg.what)
{ case DialogInterface.BUTTON_POSITIVE:
case DialogInterface.BUTTON_NEGATIVE:
case DialogInterface.BUTTON_NEUTRAL:
((DialogInterface.OnClickListener) msg.obj).onClick(mDialog
.get(), msg.what);
break ;
}
}
} 我们可以看到，上面的类和AlertController中的ButtonHandler类很像，只是支掉了switch语句的最后一个case子句（用于调用dismiss方法）和相关的代码。
下面我们就要为AlertController中的mHandler重新赋值。由于mHandler是private变量，因此，在这里需要使用Java的反射技术来为mHandler赋值。由于在AlertDialog类中的mAlert变量同样也是private，因此，也需要使用同样的反射技术来获得mAlert变量。代码如下：
先建立一个 AlertDialog 对象
AlertDialog alertDialog = new AlertDialog.Builder( this )
.setTitle( " abc " )
.setMessage( " content " )
.setIcon(R.drawable.icon)
.setPositiveButton( “确定”,
new OnClickListener()
{
@Override
public void onClick(DialogInterface dialog,
int which)
{ }
}).setNegativeButton( " 取消 " , new OnClickListener()
{ @Override
public void onClick(DialogInterface dialog, int which)
{
dialog.dismiss();
}
}).create()
上面的对话框很普通，单击哪个按钮都会关闭对话框。下面在调用 show 方法之前来修改一个 mHandler 变量的值， OK ，下面我们就来见证奇迹的时刻。 try
{

Field field = alertDialog1.getClass().getDeclaredField( " mAlert " );
field.setAccessible( true );
// 获得mAlert变量的值
Object obj = field.get(alertDialog1);
field = obj.getClass().getDeclaredField( " mHandler " );
field.setAccessible( true );
// 修改mHandler变量的值，使用新的ButtonHandler类
field.set(obj, new ButtonHandler(alertDialog1));
}
catch (Exception e)
{
}
// 显示对话框
alertDialog.show(); 我们发现，如果加上try catch语句，单击对话框中的确定按钮不会关闭对话框（除非在代码中调用dismiss方法），单击取消按钮则会关闭对话框（因为调用了dismiss方法）。如果去了try…catch代码段，对话框又会恢复正常了。
虽然上面的代码已经解决了问题，但需要编写的代码仍然比较多，为此，我们也可采用另外一种方法来阻止关闭对话框。这种方法不需要定义任何的类。
这种方法需要用点技巧。由于系统通过调用dismiss来关闭对话框，那么我们可以在dismiss方法上做点文章。在系统调用dismiss方法时会首先判断对话框是否已经关闭，如果对话框已经关闭了，就会退出dismiss方法而不再继续关闭对话框了。因此，我们可以欺骗一下系统，当调用dismiss方法时我们可以让系统以为对话框已经关闭（虽然对话框还没有关闭），这样dismiss方法就失效了，这样即使系统调用了dismiss方法也无法关闭对话框了。
下面让我们回到AlertDialog的源代码中，再继续跟踪到AlertDialog的父类Dialog的源代码中。找到dismissDialog方法。实际上，dismiss方法是通过dismissDialog方法来关闭对话框的，dismissDialog方法的代码如下： private void dismissDialog() {
if (mDecor == null ) {
if (Config.LOGV) Log.v(LOG_TAG,
" [Dialog] dismiss: already dismissed, ignore " );
return ;
}
if ( ! mShowing) {
if (Config.LOGV) Log.v(LOG_TAG,
" [Dialog] dismiss: not showing, ignore " );
return ;
} mWindowManager.removeView(mDecor); mDecor = null ;
mWindow.closeAllPanels();
onStop();
mShowing = false ;

sendDismissMessage();
}
该方法后面的代码不用管它，先看 if(!mShowing){ … } 这段代码。这个 mShowing 变量就是判断对话框是否已关闭的。因此，我们在代码中通过设置这个变量就可以使系统认为对话框已经关闭，就不再继续关闭对话框了。由于 mShowing 也是 private 变量，因此，也需要反射技术来设置这个变量。我们可以在对话框按钮的单击事件中设置 mShowing ，代码如下：
try
{
Field field = dialog.getClass()
.getSuperclass().getDeclaredField(
" mShowing " );
field.setAccessible( true );
// 将mShowing变量设为false，表示对话框已关闭
field.set(dialog, false );
dialog.dismiss();}
catch (Exception e)
{}
将上面的代码加到哪个按钮的单击事件代码中，哪个按钮就再也无法关闭对话框了。如果要关闭对话框，只需再将 mShowing 设为 true 即可。要注意的是，在一个按钮里设置了 mShowing 变量，也会影响另一个按钮的关闭对话框功能，因此，需要在每一个按钮的单击事件里都设置 mShowing 变量的值。 本文来自CSDN博客，转载请标明出处： http://blog.csdn.net/nokiaguy/archive/2010/07/27/5770263.aspx

❹ 濡备綍鍦ˋndroid涓嬩娇鐢˙inder

瀹炵幇涓涓狰inder阃氢俊瀹炰緥锛岄渶瑕佺粡杩囦互涓嬫ラわ细
锛1锛夎幏寰桽erviceManager镄勫硅薄寮旷敤

锛2锛夊悜ServiceManager娉ㄥ唽鏂扮殑Service

锛3锛夊湪Client涓阃氲繃ServiceManager銮峰缑Service瀵硅薄寮旷敤

锛3锛夊湪Client涓鍙戦佽锋眰锛岀敱Service杩斿洖缁撴灉銆

涓嬮溃鐪嫔叿浣撶殑浠ｇ爜濡备綍瀹炵幇銆

3.1 libmyservice浠ｇ爜瀹炵幇

锛1锛夋柊寤虹洰褰昮rameworks/base/myservice/libservice锛岃繘鍏ヨョ洰褰

view plain
$ cd frameworks/base
$ mkdir myservice
$ cd myservice
$ mkdir libmyservice
$ cd libmyservice

锛2锛夌紪鍐檒ibmyservice/myservic.h鏂囦欢

view plain
#include <utils/threads.h>

#include <utils/RefBase.h>

#include <binder/IInterface.h>

#include <binder/BpBinder.h>

#include <binder/Parcel.h>

namespace android {

class MyService : public BBinder

{

mutable Mutex mLock;

int32_t mNextConnId;

public:

static int instantiate();

MyService();

virtual ~MyService();

virtual status_t onTransact(uint32_t, const Parcel&, Parcel*, uint32_t);

};

}; //namespace

(2)缂栧啓libservice/myservice.cpp鏂囦欢

view plain
#include "myservice.h"

#include <binder/IServiceManager.h>

#include <binder/IPCThreadState.h>

namespace android {

static struct sigaction oldact;

static pthread_key_t sigbuskey;

int MyService::instantiate()

{

LOGE("MyService instantiate");

// defaultServiceManager ()銮峰缑ServiceManager镄勫硅薄寮旷敤锛宎ddService()鍙钖慡erviceManager娉ㄥ唽鏂扮殑链嶅姟

int r = defaultServiceManager()->addService(String16("android.myservice"), new MyService());

LOGE("MyService r = %d/n", r);

return r;

}

MyService::MyService()

{

LOGV("MyService created");

mNextConnId = 1;

pthread_key_create(&sigbuskey, NULL);

}

MyService::~MyService()

{

pthread_key_delete(sigbuskey);

LOGV("MyService destroyed");

}

// 姣忎釜绯荤粺链嶅姟閮界户镓胯嚜BBinder绫伙纴閮藉簲閲嶅啓BBinder镄刼nTransact铏氩嚱鏁般傚綋鐢ㄦ埛鍙戦佽锋眰鍒拌揪Service镞讹纴绯荤粺妗嗘灦浼氲皟鐢⊿ervice镄刼nTransact鍑芥暟锛岃ュ嚱鏁板垎鏋愭帴鏀跺埌镄勬暟鎹鍖咃纴璋幂敤鐩稿簲镄勬帴鍙ｅ嚱鏁板勭悊璇锋眰

status_t MyService::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

switch(code)

{

case 0: {

pid_t pid = data.readInt32();

int num = data.readInt32();

num = num + 100;

reply->writeInt32(num);

return NO_ERROR;

}

break;

default:

return BBinder::onTransact(code, data, reply, flags);

}

}

}; //namespace

锛3锛夌紪鍐檒ibservice/Android.mk鏂囦欢

view plain
# File: Android.mk
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := myservice.cpp
LOCAL_C_INCLUDES := $(JNI_H_INCLUDE)
LOCAL_SHARED_LIBRARIES := libutils libbinder
LOCAL_MODULE_TAGS := optional
LOCAL_PRELINK_MODULE := false
LOCAL_MODULE := libmyservice

include $(BUILD_SHARED_LIBRARY)

锛4锛夌紪璇憀ibmyservice.so锷ㄦ佸簱

鍦╝ndroid婧愮爜涓荤洰褰曚笅

view plain
$ source build/envsetup.sh

including device/htc/passion/vendorsetup.sh

including device/samsung/crespo4g/vendorsetup.sh

including device/samsung/crespo/vendorsetup.sh

$ mmm frameworks/base/myservice/libmyservice/

缂栬疟鎴愬姛钖庣敓鎴愭枃浠讹细out/target/proct/generic/system/lib/libmyservice.so

❺ 如何hook android sdk

1.1 概述
Xposed 是 GitHUB 上 rovo89 大大设计的一个针对 Android 平台的动态劫持项目，通过替换 /system/bin/app_process 程序控制 zygote 进程，使得 app_process 在启动过程中会加载 XposedBridge.jar 这个 jar 包，从而完成对系统应用的劫持。
Xposed 框架的基本运行环境如下：

因为 Xposed 工作原理是在 /system/bin 目录下替换文件，在 install 的时候需要root 权限，但是运行时不需要 root 权限。

需要在 Android 4.0 以上版本的机器中

2. GitHub 上的 Xposed 资源梳理一下，可以这么分类：
XposedBridge.jar ： XposedBridge.jar 是 Xposed 提供的 jar 文件，负责在 Native层与 FrameWork 层进行交互。 /system/bin/app_process 进程启动过程中会加载该jar 包，其它的 Moles 的开发与运行都是基于该 jar 包的。
Xposed ： Xposed 的 C++ 部分，主要是用来替换 /system/bin/app_process ，并为 XposedBridge 提供 JNI 方法。
XposedInstaller ： Xposed 的安装包，负责配置 Xposed 工作的环境并且提供对基于 Xposed 框架的 Moles 的管理。
XposedMods ：使用 Xposed 开发的一些 Moles ，其中 AppSettings 是一个可以进行权限动态管理的应用
1.2 Mechanism ：原理
1.2.1 Zygote
在 Android 系统中，应用程序进程都是由 Zygote 进程孵化出来的，而 Zygote 进程是由 Init 进程启动的。 Zygote 进程在启动时会创建一个 Dalvik 虚拟机实例，每当它孵化一个新的应用程序进程时，都会将这个 Dalvik 虚拟机实例复制到新的应用程序进程里面去，从而使得每一个应用程序进程都有一个独立的 Dalvik 虚拟机实例。
Zygote 进程在启动的过程中，除了会创建一个 Dalvik 虚拟机实例之外，还会将 Java运行时库加载到进程中来，以及注册一些 Android 核心类的 JNI 方法来前面创建的 Dalvik 虚拟机实例中去。注意，一个应用程序进程被 Zygote 进程孵化出来的时候，不仅会获得 Zygote 进程中的 Dalvik 虚拟机实例拷贝，还会与 Zygote 一起共享 Java 运行时库。这也就是可以将XposedBridge 这个 jar 包加载到每一个 Android 应用程序中的原因。 XposedBridge 有一个私有的 Native （ JNI ）方法 hookMethodNative，这个方法也在 app_process 中使用。这个函数提供一个方法对象利用 Java 的 Reflection 机制来对内置方法覆写。具体的实现可以看下文的 Xposed 源代码分析。
1.2.2 Hook/Replace
Xposed 框架中真正起作用的是对方法的 hook 。在 Repackage 技术中，如果要对APK 做修改，则需要修改 Smali 代码中的指令。而另一种动态修改指令的技术需要在程序运行时基于匹配搜索来替换 smali 代码，但因为方法声明的多样性与复杂性，这种方法也比较复杂。
在 Android 系统启动的时候， zygote 进程加载 XposedBridge 将所有需要替换的 Method 通过 JNI 方法 hookMethodNative 指向 Native 方法 xposedCallHandler ， xposedCallHandler 在转入 handleHookedMethod 这个 Java 方法执行用户规定的 Hook Func 。
XposedBridge 这个 jar 包含有一个私有的本地方法： hookMethodNative ，该方法在附加的 app_process 程序中也得到了实现。它将一个方法对象作为输入参数（你可以使用 Java 的反射机制来获取这个方法）并且改变 Dalvik 虚拟机中对于该方法的定义。它将该方法的类型改变为 native 并且将这个方法的实现链接到它的本地的通用类的方法。换言之，当调用那个被 hook 的方法时候，通用的类方法会被调用而不会对调用者有任何的影响。在 hookMethodNative 的实现中，会调用 XposedBridge中的handleHookedMethod这个方法来传递参数。 handleHookedMethod 这个方法类似于一个统一调度的 Dispatch 例程，其对应的底层的 C++ 函数是 xposedCallHandler 。而 handleHookedMethod 实现里面会根据一个全局结构 hookedMethodCallbacks 来选择相应的 hook函数，并调用他们的 before, after 函数。
当多模块同时 Hook 一个方法的时候， Xposed 会自动根据 Mole 的优先级来排序，调用顺序如下：
A.before -> B.before -> original method -> B.after -> A.after
2 源代码分析
2.1 Cpp 模块
其文件分类如下：
app_main.cpp ：类似 AOSP 中的 frameworks/base/cmds/app_process/app_main.cpp，即/system/bin/app_process 这个 zygote 真实身份的应用程序的源代码。关于zygote 进程的分析可以参照 Android:AOSP&Core 中的 Zygote 进程详解。
xposed.cpp ：提供给 app_main.cpp 的调用函数以及 XposedBridge 的 JNI 方法的实现。主要完成初始化工作以及 Framework 层的 Method 的 Hook 操作。
xposed.h ， xposed_offsets.h ：头文件
Xposed 框架中的 app_main.cpp 相对于 AOSP 的 app_main.cpp 中修改之处主要为区分了调用 runtime.start() 函数的逻辑。 Xposed 框架中的 app_main.cpp 在此处会根据情况选择是加载 XposedBridge 类还是 ZygoteInit 或者 RuntimeInit 类。而实际的加载 XposedBridge 以及注册 JNI 方法的操作发生在第四步： xposedOnVmCreated中。
1．包含 cutils/properties.h ，主要用于获取、设置环境变量， xposed.cpp 中需要将XposedBridge 设置到 ClassPath 中。
2．包含了 dlfcn.h ，用于对动态链接库的操作。
3．包含了 xposed.h ，需要调用 xposed.cpp 中的函数，譬如在虚拟机创建时注册 JNI 函数。
4．增加了 initTypePointers 函数，对于 Android SDK 大于等于 18 的会获取到 atrace_set_tracing_enabled 函数指针，在 Zygote 启动时调用。
5．AppRuntime 类中的 onVmCreated 函数中增加 xposedOnVmCreated 函数调用。
6．源代码中的 Log* 全部重命名为 ALog*, 所以 Logv 替换为 Alogv ，但是功能不变。
7．Main 函数开始处增加了大量的代码，但是对于 SDK 版本小于 16 的可以不用考虑。

2.1.1 Main 函数： zygote 入口
int main(int argc, char* const argv[])

❻ Java程序 android log.v能打印十六进制的数据

Log.e("string","answer"+Integer.toHexString(your num.));

❼ android中camera的hal模块怎么被调用

CameraService.cpp (frameworks\base\services\camera\libcameraservice)

中调用hw_get_mole

[cpp] view plain print?
void CameraService::onFirstRef()
{
BnCameraService::onFirstRef();

<span style="color: rgb(255, 0, 0);">if (hw_get_mole(CAMERA_HARDWARE_MODULE_ID,
(const hw_mole_t **)&mMole) < 0)</span> {
LOGE("Could not load camera HAL mole");
mNumberOfCameras = 0;
}
else {
mNumberOfCameras = mMole->get_number_of_cameras();
if (mNumberOfCameras > MAX_CAMERAS) {
LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
mNumberOfCameras, MAX_CAMERAS);
mNumberOfCameras = MAX_CAMERAS;
}
for (int i = 0; i < mNumberOfCameras; i++) {
setCameraFree(i);
}
}
}
void CameraService::onFirstRef()
{
BnCameraService::onFirstRef();

if (hw_get_mole(CAMERA_HARDWARE_MODULE_ID,
(const hw_mole_t **)&mMole) < 0) {
LOGE("Could not load camera HAL mole");
mNumberOfCameras = 0;
}
else {
mNumberOfCameras = mMole->get_number_of_cameras();
if (mNumberOfCameras > MAX_CAMERAS) {
LOGE("Number of cameras(%d) > MAX_CAMERAS(%d).",
mNumberOfCameras, MAX_CAMERAS);
mNumberOfCameras = MAX_CAMERAS;
}
for (int i = 0; i < mNumberOfCameras; i++) {
setCameraFree(i);
}
}
}

看一下hw_get_mole是怎么回事

[cpp] view plain print?
int hw_get_mole(const char *id, const struct hw_mole_t **mole)
{
return <span style="color: rgb(255, 0, 0);">hw_get_mole_by_class(id, NULL, mole);
</span>}
int hw_get_mole(const char *id, const struct hw_mole_t **mole)
{
return hw_get_mole_by_class(id, NULL, mole);
}

他只是一个封装实际调用了[email protected] (hardware\libhardware）
好在不长，看看吧

[cpp] view plain print?
int hw_get_mole_by_class(const char *class_id, const char *inst,
const struct hw_mole_t **mole)
{
int status;
int i;
const struct hw_mole_t *hmi = NULL;
<span style="color: rgb(255, 0, 0);"> char prop[PATH_MAX];//几个关键的数组
char path[PATH_MAX];//在下面起了重要
char name[PATH_MAX];//作用
</span>
if (inst)
snprintf(name, PATH_MAX, "%s.%s", class_id, inst);
else
strlcpy(name, class_id, PATH_MAX);//走这里

/*
* Here we rely on the fact that calling dlopen multiple times on
* the same .so will simply increment a refcount (and not load
* a new of the library).
* We also assume that dlopen() is thread-safe.
*/

/* Loop through the configuration variants looking for a mole */
for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {
if (i < HAL_VARIANT_KEYS_COUNT) {
if (property_get(variant_keys[i], prop, NULL) == 0)
<span style="color: rgb(255, 0, 0);">//在这里将prop的路径得到，分别从
"ro.hardware[qcom]"
"ro.proct.board"[7x27],
"ro.board.platform"[msm7627a],
"ro.arch",
"ro.hw_platform"[QRD_SKU3-1100]
这几个属性文件中获得硬件的信息
有些硬件信息的字符串会出现在编译后生成的.so名字中</span>
{
continue;
}
snprintf(path, sizeof(path), "%s/%s.%s.so",
HAL_LIBRARY_PATH2, name, prop);
if (access(path, R_OK) == 0) break;

snprintf(path, sizeof(path), "%s/%s.%s.so",
HAL_LIBRARY_PATH1, name, prop);<span style="color: rgb(255, 0, 0);">//走这里,在这里得到/system/lib/hw/camera.msm7627a.so
这样一个路径，这个库里有QualcommCamera.cpp，这是
camera模块HAL代码开始的地方</span>
if (access(path, R_OK) == 0) break;
} else {
snprintf(path, sizeof(path), "%s/%s.default.so",
HAL_LIBRARY_PATH1, name);
if (access(path, R_OK) == 0) break;
}
}

status = -ENOENT;
if (i < HAL_VARIANT_KEYS_COUNT+1) {
/* load the mole, if this fails, we're doomed, and we should not try
* to load a different variant. */
status = load(class_id, path, mole);<span style="color: rgb(255, 0, 0);">//这里关键,函数的三个参数可以串联成一句话：
到path（/system/lib/hw/camera.msm7627a.so）这个路径下找到一个id（camera）匹配的mole</span>
}

return status;
}
int hw_get_mole_by_class(const char *class_id, const char *inst,
const struct hw_mole_t **mole)
{
int status;
int i;
const struct hw_mole_t *hmi = NULL;
char prop[PATH_MAX];//几个关键的数组
char path[PATH_MAX];//在下面起了重要
char name[PATH_MAX];//作用

if (inst)
snprintf(name, PATH_MAX, "%s.%s", class_id, inst);
else
strlcpy(name, class_id, PATH_MAX);//走这里

/*
* Here we rely on the fact that calling dlopen multiple times on
* the same .so will simply increment a refcount (and not load
* a new of the library).
* We also assume that dlopen() is thread-safe.
*/

/* Loop through the configuration variants looking for a mole */
for (i=0 ; i<HAL_VARIANT_KEYS_COUNT+1 ; i++) {
if (i < HAL_VARIANT_KEYS_COUNT) {
if (property_get(variant_keys[i], prop, NULL) == 0)
//在这里将prop的路径得到，分别从
"ro.hardware[qcom]"
"ro.proct.board"[7x27],
"ro.board.platform"[msm7627a],
"ro.arch",
"ro.hw_platform"[QRD_SKU3-1100]
这几个属性文件中获得硬件的信息
有些硬件信息的字符串会出现在编译后生成的.so名字中
{
continue;
}
snprintf(path, sizeof(path), "%s/%s.%s.so",
HAL_LIBRARY_PATH2, name, prop);
if (access(path, R_OK) == 0) break;

snprintf(path, sizeof(path), "%s/%s.%s.so",
HAL_LIBRARY_PATH1, name, prop);//走这里,在这里得到/system/lib/hw/camera.msm7627a.so
这样一个路径，这个库里有QualcommCamera.cpp，这是
camera模块HAL代码开始的地方
if (access(path, R_OK) == 0) break;
} else {
snprintf(path, sizeof(path), "%s/%s.default.so",
HAL_LIBRARY_PATH1, name);
if (access(path, R_OK) == 0) break;
}
}

status = -ENOENT;
if (i < HAL_VARIANT_KEYS_COUNT+1) {
/* load the mole, if this fails, we're doomed, and we should not try
* to load a different variant. */
status = load(class_id, path, mole);//这里关键,函数的三个参数可以串联成一句话：
到path（/system/lib/hw/camera.msm7627a.so）这个路径下找到一个id（camera）匹配的mole
}

return status;
}

再来看看load这个函数@hardware.c (hardware\libhardware)

[cpp] view plain print?
static int load(const char *id,
const char *path,
const struct hw_mole_t **pHmi)
{
int status;
void *handle;
struct hw_mole_t *hmi;

/*
* load the symbols resolving undefined symbols before
* dlopen returns. Since RTLD_GLOBAL is not or'd in with
* RTLD_NOW the external symbols will not be global
*/
handle = dlopen(path, RTLD_NOW);
if (handle == NULL) {
char const *err_str = dlerror();
LOGE("load: mole=%s\n%s", path, err_str?err_str:"unknown");
status = -EINVAL;
goto done;
}

<span style="color: rgb(255, 0, 0);"> /* Get the address of the struct hal_mole_info. */
const char *sym = HAL_MODULE_INFO_SYM_AS_STR;
hmi = (struct hw_mole_t *)dlsym(handle, sym);
</span> if (hmi == NULL) {
LOGE("load: couldn't find symbol %s", sym);
status = -EINVAL;
goto done;
}

/* Check that the id matches */
if (strcmp(id, hmi->id) != 0) {
LOGE("load: id=%s != hmi->id=%s", id, hmi->id);
status = -EINVAL;
goto done;
}

hmi->dso = handle;

/* success */
status = 0;

done:
if (status != 0) {
hmi = NULL;
if (handle != NULL) {
dlclose(handle);
handle = NULL;
}
} else {
LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",
id, path, *pHmi, handle);
}

*pHmi = hmi;

return status;
}
static int load(const char *id,
const char *path,
const struct hw_mole_t **pHmi)
{
int status;
void *handle;
struct hw_mole_t *hmi;

/*
* load the symbols resolving undefined symbols before
* dlopen returns. Since RTLD_GLOBAL is not or'd in with
* RTLD_NOW the external symbols will not be global
*/
handle = dlopen(path, RTLD_NOW);
if (handle == NULL) {
char const *err_str = dlerror();
LOGE("load: mole=%s\n%s", path, err_str?err_str:"unknown");
status = -EINVAL;
goto done;
}

/* Get the address of the struct hal_mole_info. */
const char *sym = HAL_MODULE_INFO_SYM_AS_STR;
hmi = (struct hw_mole_t *)dlsym(handle, sym);
if (hmi == NULL) {
LOGE("load: couldn't find symbol %s", sym);
status = -EINVAL;
goto done;
}

/* Check that the id matches */
if (strcmp(id, hmi->id) != 0) {
LOGE("load: id=%s != hmi->id=%s", id, hmi->id);
status = -EINVAL;
goto done;
}

hmi->dso = handle;

/* success */
status = 0;

done:
if (status != 0) {
hmi = NULL;
if (handle != NULL) {
dlclose(handle);
handle = NULL;
}
} else {
LOGV("loaded HAL id=%s path=%s hmi=%p handle=%p",
id, path, *pHmi, handle);
}

*pHmi = hmi;

return status;
}

在打开的.so（camera.msm7627a.so）中查找HMI符号的地址,并保存在hmi中。至此,.so中的hw_mole_t已经被成功获取,从而可以根
据它获取别的相关接口。
1)HAL通过hw_get_mole函数获取hw_mole_t
2)HAL通过hw_mole_t->methods->open获取hw_device_t指针,并在此open函数中初始化hw_device_t的包装结构中的
函数及hw_device_t中的close函数,如gralloc_device_open。
3)三个重要的数据结构:
a) struct hw_device_t: 表示硬件设备,存储了各种硬件设备的公共属性和方法
b)struct hw_mole_t: 可用hw_get_mole进行加载的mole
c)struct hw_mole_methods_t: 用于定义操作设备的方法,其中只定义了一个打开设备的方法open.

❽ 闂棰樻眰锷╋纴阃氲繃ndk鍦ㄦ湰鍦癈浠ｇ爜涓瀹炵幇Surface鏄剧ず

浣犲彲浠ュ弬钥僋DK鍖呴噷闱㈢殑sample锛歛ndroid-ndk-r10samples ative-codec銆傞噷闱㈡湁濡备綍浠巎ava灞备紶阃扴urface鍒皀ative鍒颁唬镰侊细

/**Nativemethods,implementedinjnifolder*/
();
(Stringfilename);
(booleanisPlaying);
();
(Surfacesurface);
();

{
;
GLViewVideoSink(){
mMyGLSurfaceView=myGLSurfaceView;
}
@Override
voidsetFixedSize(intwidth,intheight){
}
@Override
voiseAsSinkForNative(){
SurfaceTexturest=mMyGLSurfaceView.getSurfaceTexture();
Surfaces=newSurface(st);
setSurface(s);
s.release();
}
}

native code锛

//setthesurface
voidJava_com_example_nativecodec_NativeCodec_setSurface(JNIEnv*env,jclassclazz,jobjectsurface)
{
//
if(data.window){
ANativeWindow_release(data.window);
data.window=NULL;
}
data.window=ANativeWindow_fromSurface(env,surface);
LOGV("@@@setsurface%p",data.window);
}