android回调线程
① Android创建子线程和回调主线程的几种方式
在一个Android 程序开始运行的时候，会单独启动一个Process。默认的情况下，所有这个程序中的Activity或者Service（Service和 Activity只是Android提供的Components中的两种，除此之外还有Content Provider和Broadcast Receiver）都会跑在这个Process。
一个Android 程序默认情况下也只有一个Process，但一个Process下却可以有许多个Thread。在这么多Thread当中，有一个Thread，我们称之为UI Thread。UI Thread在Android程序运行的时候就被创建，是一个Process当中的主线程Main Thread，主要是负责控制UI界面的显示、更新和控件交互。在Android程序创建之初，一个Process呈现的是单线程模型，所有的任务都在一个线程中运行。因此，我们认为，UI Thread所执行的每一个函数，所花费的时间都应该是越短越好。而其他比较费时的工作（访问网络，下载数据，查询数据库等），都应该交由子线程去执行，以免阻塞主线程。
那么，UI Thread如何和其他Thread一起工作呢？常用方法是：
诞生一个主线程的Handler物件，当做Listener去让子线程能将讯息Push到主线程的Message Quene里，以便触发主线程的handlerMessage（）函数，让主线程知道子线程的状态，并在主线程更新UI。
② android四大组件的回调函数哪些是在ui主线程执行
四大组件，如果不是在子线程的回调，都是在主线程。
③ 请问android中一些第三方网络请求框架的回调函数都是运行在主线程还是子线程注意，是回调函数所
主线程吧 我记得像是XUitls 的连网回调函数。在onsuccess 和 onfailure 方法里面，可以直接关闭弹出的联网进度条 既然可以修改控件，应该就是在主线程了吧
④ Android 如何监听一个线程的开始和结束
方法一：轮询
比如主线程要等子线程在得到变量“val”值的时候开始用“val”的值来进行工作，这个比较简单。
方法二，回调
回调就是调用别的对象的方法时把“自己”传进去，然后别的对象在某个时候调用“自己的方法”
java">publicinterfaceThreadCallback{
voidthreadStartLisener();
voidthreadEndLisener();
}{
;
publicSubRunnable(ThreadCallbackthreadCallback){
this.mThreadCallback=threadCallback;
}
@Override
publicvoidrun(){
mThreadCallback.threadStartLisener();
for(inti=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"dosomething"+i);
}
mThreadCallback.threadEndLisener();
}
}{
=newThreadCallbackTest();
publicstaticvoidmain(String[]args){
System.out.println(Thread.currentThread().getName()+"开始");
newThread(newSubRunnable(mThreadCallbackTest)).start();
}
@Override
publicvoidthreadStartLisener(){
System.out.println(Thread.currentThread().getName()+"线程，知道SubRunnable线程开始执行任务了");
}
@Override
publicvoidthreadEndLisener(){
System.out.println(Thread.currentThread().getName()+"线程，知道SubRunnable线程任务执行结束了");
}
}
⑤ 如何在android的jni线程中实现回调
jni回调是指在c/c++代码中调用java函数，当在c/c++的线程中执行回调函数时，会导致回调失败。
其中一种在Android系统的解决方案是：
把c/c++中所有线程的创建，由pthread_create函数替换为由Java层的创建线程的函数AndroidRuntime::createJavaThread。
假设有c++函数:
[cpp] view plain
void *thread_entry(void *args)
{
while(1)
{
printf("thread running...\n");
sleep(1);
}
}
void init()
{
pthread_t thread;
pthread_create(&thread,NULL,thread_entry,(void *)NULL);
}
init()函数创建一个线程，需要在该线程中调用java类Test的回调函数Receive:
[cpp] view plain
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback:" + msg;
Log.d("Test", msg);
}
首先在c++中定义回调函数指针：
[cpp] view plain
//test.h
#include <pthread.h>
//function type for receiving data from native
typedef void (*ReceiveCallback)(unsigned char *buf, int len);
/** Callback for creating a thread that can call into the Java framework code.
* This must be used to create any threads that report events up to the framework.
*/
typedef pthread_t (* CreateThreadCallback)(const char* name, void (*start)(void *), void* arg);
typedef struct{
ReceiveCallback recv_cb;
CreateThreadCallback create_thread_cb;
}Callback;
再修改c++中的init和thread_entry函数：
[cpp] view plain
//test.c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/wait.h>
#include <unistd.h>
#include "test.h"
void *thread_entry(void *args)
{
char *str = "i'm happy now";
Callback cb = NULL;
int len;
if(args != NULL){
cb = (Callback *)args;
}
len = strlen(str);
while(1)
{
printf("thread running...\n");
//invoke callback method to java
if(cb != NULL && cb->recv_cb != NULL){
cb->recv_cb((unsigned char*)str, len);
}
sleep(1);
}
}
void init(Callback *cb)
{
pthread_t thread;
//pthread_create(&thread,NULL,thread_entry,(void *)NULL);
if(cb != NULL && cb->create_thread_cb != NULL)
{
cb->create_thread_cb("thread",thread_entry,(void *)cb);
}
}
然后在jni中实现回调函数，以及其他实现：
[cpp] view plain
//jni_test.c
#include <stdlib.h>
#include <malloc.h>
#include <jni.h>
#include <JNIHelp.h>
#include "android_runtime/AndroidRuntime.h"
#include "test.h"
#define RADIO_PROVIDER_CLASS_NAME "com/tonny/Test"
using namespace android;
static jobject mCallbacksObj = NULL;
static jmethodID method_receive;
static void (JNIEnv* env, const char* methodName) {
if (env->ExceptionCheck()) {
LOGE("An exception was thrown by callback '%s'.", methodName);
LOGE_EX(env);
env->ExceptionClear();
}
}
static void receive_callback(unsigned char *buf, int len)
{
int i;
JNIEnv* env = AndroidRuntime::getJNIEnv();
jcharArray array = env->NewCharArray(len);
jchar *pArray ;
if(array == NULL){
LOGE("receive_callback: NewCharArray error.");
return;
}
pArray = (jchar*)calloc(len, sizeof(jchar));
if(pArray == NULL){
LOGE("receive_callback: calloc error.");
return;
}
// buffer to jchar array
for(i = 0; i < len; i++)
{
*(pArray + i) = *(buf + i);
}
// buffer to jcharArray
env->SetCharArrayRegion(array,0,len,pArray);
//invoke java callback method
env->CallVoidMethod(mCallbacksObj, method_receive,array,len);
//release resource
env->DeleteLocalRef(array);
free(pArray);
pArray = NULL;
(env, __FUNCTION__);
}
static pthread_t create_thread_callback(const char* name, void (*start)(void *), void* arg)
{
return (pthread_t)AndroidRuntime::createJavaThread(name, start, arg);
}
static Callback mCallbacks = {
receive_callback,
create_thread_callback
};
static void jni_class_init_native
(JNIEnv* env, jclass clazz)
{
method_receive = env->GetMethodID(clazz, "Receive", "([CI)V");
}
static int jni_init
(JNIEnv *env, jobject obj)
{
if (!mCallbacksObj)
mCallbacksObj = env->NewGlobalRef(obj);
return init(&mCallbacks);
}
static const JNINativeMethod gMethods[] = {
{ "class_init_native", "()V", (void *)jni_class_init_native },
{ "native_init", "()I", (void *)jni_init },
};
static int registerMethods(JNIEnv* env) {
const char* const kClassName = RADIO_PROVIDER_CLASS_NAME;
jclass clazz;
/* look up the class */
clazz = env->FindClass(kClassName);
if (clazz == NULL) {
LOGE("Can't find class %s/n", kClassName);
return -1;
}
/* register all the methods */
if (env->RegisterNatives(clazz,gMethods,sizeof(gMethods)/sizeof(gMethods[0])) != JNI_OK)
{
LOGE("Failed registering methods for %s/n", kClassName);
return -1;
}
/* fill out the rest of the ID cache */
return 0;
}
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env = NULL;
jint result = -1;
LOGI("Radio JNI_OnLoad");
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
LOGE("ERROR: GetEnv failed/n");
goto fail;
}
if(env == NULL){
goto fail;
}
if (registerMethods(env) != 0) {
LOGE("ERROR: PlatformLibrary native registration failed/n");
goto fail;
}
/* success -- return valid version number */
result = JNI_VERSION_1_4;
fail:
return result;
}
jni的Android.mk文件中共享库设置为：
[cpp] view plain
LOCAL_SHARED_LIBRARIES := liblog libcutils libandroid_runtime libnativehelper
最后再实现Java中的Test类：
[java] view plain
//com.tonny.Test.java
public class Test {
static{
try {
System.loadLibrary("test");
class_init_native();
} catch(UnsatisfiedLinkError ule){
System.err.println("WARNING: Could not load library libtest.so!");
}
}
public int initialize() {
return native_radio_init();
}
public void Receive(char buffer[],int length){
String msg = new String(buffer);
msg = "received from jni callback" + msg;
Log.d("Test", msg);
}
protected static native void class_init_native();
protected native int native_init();
}
⑥ android 按钮接口回调是怎么回到主线程的
SurfaceView是View的子类，它内嵌了一个专门用于绘制的Surface，你可以控制这个Surface的格式和尺寸，Surfaceview控制这个Surface的绘制位置。surface是纵深排序(Z-ordered)的，说明它总在自己所在窗口的后面。SurfaceView提供了一个可见区域，只有在这个可见区域内的surface内容才可见。surface的排版显示受到视图层级关系的影响，它的兄弟视图结点会在顶端显示。这意味者 surface的内容会被它的兄弟视图遮挡，这一特性可以用来放置遮盖物(overlays)(例如，文本和按钮等控件)。注意，如果surface上面有透明控件，那么每次surface变化都会引起框架重新计算它和顶层控件的透明效果，这会影响性能。 SurfaceView默认使用双缓冲技术的，它支持在子线程中绘制图像，这样就不会阻塞主线程了，所以它更适合于游戏的开发。 SurfaceView的使用 首先继承SurfaceView，并实现SurfaceHolder.Callback接口，实现它的三个方法：surfaceCreated，surfaceChanged，surfaceDestroyed。 surfaceCreated(SurfaceHolder holder)：surface创建的时候调用，一般在该方法中启动绘图的线程。 surfaceChanged(SurfaceHolder holder, int format, int width,int height)：surface尺寸发生改变的时候调用，如横竖屏切换。 surfaceDestroyed(SurfaceHolder holder) ：surface被销毁的时候调用，如退出游戏画面，一般在该方法中停止绘图线程。 还需要获得SurfaceHolder，并添加回调函数，这样这三个方法才会执行。 SurfaceView实战 下面通过一个小demo来学习SurfaceView在实际项目中的使用，绘制一个精灵，该精灵有四个方向的行走动画，让精灵沿着屏幕四周不停的行走。
⑦ Android创建子线程和回调主线程的几种方式
主线程吧
我记得像是xuitls
的连握老网回调函数。在onsuccess
和
onfailure
方法里面，可以直接关闭弹出的联网改森进度条
既然可以修改控段歼升件，应该就是在主线程了吧
⑧ Android主线程到底是什么
Android中关于主线程的理解：
Android的主线程是UI线程，在Android中，四大组件运行在主线程中，在主线程中做耗时操作会导致程序出现卡顿甚至出现ANR异常，一个基本常识就是将耗时操作放到子线程中去处理，然后通过Handler回调到主线程。
有三点还需要注意：
因为四大组件运行在一个主线程中，那么若果当前界面在显示的时候，后台的activity仍有处理逻辑再运行的话，仍然会造成当前界面的卡顿。
通过Handler回调到主线程只是避免程序出现ANR的第一步，必须要注意handler中逻辑处理的耗时，如果将很多消息都扔给了handler，那么也会给主线程造成压力，导致程序运行卡顿。
四大组件、Handler都是在一个线程中，那么主线程在同一时刻不可能发送两个广播，换句话说就是若果能够保证所有的广播都是在主线程中发送，那么广播内部其实不需要加上对异步操作的处理。