精华内容
下载资源
问答
  • 对象之间通信

    千次阅读 2013-05-25 19:14:58
    对象之间进行通信最基本的方式就是消息传递,在Cocoa中提供Notification Center机制来完成这一任务。其主要作用就是负责在任意两个对象之间进行通信。使用方法很简单,如下几个步骤即可:  假设A与B之间进行通信...

    对象之间进行通信最基本的方式就是消息传递,在Cocoa中提供Notification Center机制来完成这一任务。其主要作用就是负责在任意两个对象之间进行通信。使用方法很简单,如下几个步骤即可:

      假设A与B之间进行通信,B来触发事件,A接受该事件,并作出响应。
      1) A编写自定义的消息响应函数update
      2) A向消息中心注册,[NSNotificationCenter defaultCenter] addObserver: self selector:@selector(update) name:@"updateKey" object:nil];
      3) B触发事件,[[NSNotificationCenter defaultCenter] postNotificationName:@"updateKey" object:nil];

      每一个进程都有一个默认的NSNotificationCenter,可以通过类方法defaultCenter获取该消息中心的实例。消息中心可以处理同一进程中不同对象之间的消息。如果要在同一台机器上进行进程间的通信,需要使用NSDistributedNotificationCenter。

      消息中心以同步的方式将消息分发到所有的观察者中,换言之,直到所有的观察者都收到消息并处理完毕以后,控制权才会回到调用者的手里。如果需要异步的处理消息,需要使用通知队列NSNotificationQueue。

      在多线程程序中,通知会被分发到每一个发起消息的线程中,这可能与观察者注册时所在的线程已经不是同一线程。

    1. 消息处理事件postNotificationName和addObserver的调用:
          1)定义消息创建的关联值,也就是找到方法的标识
    1
    2
    3
    NSString *myNotification = @"myNotification";
    myNotification是变量,@“myNotification”这个值存于通知中心中,信息中心通过这个值来识别变量。
          2)调用信息
    1
    2
    3
    4
    NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
    [center postNotificationName:myNotification object:nil userInfo:[NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt:SMSRecommendNotification] , @"actcode",nil]];
    [NSDictionary dictionaryWithObjectsAndKeys: [NSNumber numberWithInt:SMSRecommendNotification],这个是传递给-(void)onToIphone:(NSNotification*)notify 的参数
    展开全文
  • 对象之间的调用机制 通信方式

    千次阅读 2015-10-18 16:51:26
    1.直接方法调用 2.Target-Action @selector() 3.Delegate 协议 ...1.判断通信对象是一对一的还是一对多的(一般一对一的是1,2,5,一对多是3,4,6)...2.对象之间的耦合度,是强耦合还是松耦合(尽量让所有模块解

    1.直接方法调用

    2.Target-Action @selector()

    3.Delegate 协议

    4.block(回调)

    5.KVO

    6.通知(NSNotification)


    确定使用方式

    1.判断通信对象是一对一的还是一对多的(一般一对一的是1,2,5,一对多是3,4,6)

    2.对象之间的耦合度,是强耦合还是松耦合(尽量让所有模块解耦,遵循高内聚低耦合)


    Objective-C中的通知由于其广播性及松耦合性,非常适合于大的范围内对象之间的通信(模块与模块,或一些框架层级)。通知使用起来非常方便,也正因为如此,所以容易导致滥用。所以在使用前还是需要多想想,是否有更好的方法来实现我们所需要的对象间通信。毕竟,通知机制会在一定程度上会影响到程序的性能

    通知机制在一定程度上比较消耗性能

    建议:

    1.在需要的时候,需要的地方使用通知,跨度比较大的对象间交流

    2.注册观察者和移除观察者在同一个地方要成对出现,只要注册一定要记得移除

    3.尽可能迟的去注册一个观察者,并尽可能早的将其移除,因为,每post一个通知都会是遍历通知中心的分发表,确保通知分发给每一个观察者。

    4.通知的post和add oberserve是在同一个线程中

    5.使用addObserverForName:object:queue:usingBlock:方法时候,防止循环引用

    6.NSNotification是线程安全的,但是还是不要在多线程编程的时候忽略它的线程问题


    展开全文
  • C++对象之间通信

    千次阅读 2010-12-11 21:08:00
    一直学习C++并使用C++完成了一个一个作 业和项目,然而对C++类对象之间通信总有种不知所措就好像人吃了饭... 在将对象消息传递方法之前,我们先声明C++对象之间消息传递区别于windows消息传递。这是两个

    一直学习C++并使用C++完成了一个一个作 业和项目,然而对C++类对象之间的通信总有种不知所措就好像人吃了饭自然会消化那样只知其然,不知起所以然的感觉。人,活着,好多时候是在寻找真理,其 实说俗点就是在找一个自己能够容易接受的理由来说服自己。只是其会这样而不知为什么会这样有时会使人自己遭受心魔攻击。笔者就在写程序时总有股困扰在心中 挥之不去。于是,今天我决定狠下心驱除扰我已久心魔。

    在将对象消息传递方法之前,我们先声明C++对象之间消息传递区别于windows消息传递。这是两个完全不同的概念。C++对象之间通信消息是对 象A通过传参、全局数据等共有资源的修改,然后由对象B去调用自己的函数进行数据成员或全局数据的操作更新。该传递过程是在程序中实现,而windows 消息传递一般由操作系统对桌面或键盘进行捕捉后交由应用程序处理,不直接涉及到具体对象。

    C++对象之间通信总结有3点:

    (1) 通过定义消息结构体模拟windows进行消息传递。

    (2)对象A 通过对共享数据区和参数传递的修改后调用另一对象B的函数接口进行操作,实现消息之间通信。

    (3) 让对象A成为对象B的数据成员,实现消息通信

    展开全文
  • 安卓中不同APP之间消息通信

    万次阅读 2016-04-15 14:13:13
    昨天在腾讯实习生招聘初试面试时面试官问道我关于两个APP之间相互通信的方式,当时自己回道到了contentProvider与BroadcastReceiver...自己上网查了一下相关知识,根据自己的理解将安卓中不同APP之间消息通信总结如下:

    昨天在腾讯实习生招聘初试面试时面试官问道我关于两个APP之间相互通信的方式,当时自己回道到了contentProvider与BroadcastReceiver。但他接着问还有没有其它的方式,我跟他说可以使用AIDL,但是当时没说清楚,所以最后我说目前只知道这两种方式,然后他说可以使用文件的方式或云端存储的方式共享。面试回来后自己上网查了一下相关知识,根据自己的理解将安卓中不同APP之间消息通信总结如下:


    首先要明白消息通信一般包括两种,一种是简单的数据访问,如ContentProvider,使用文件或云端方式共享,一种是消息的传递(传递的任然是数据,但不再是单纯的数据访问,而是组件之间的相互通信),如AIDL,BroadcastReceiver,Messenger。


    一使用ContentProvider

    ContentProvider(内容提供者)是Android中的四大组件之一,内容提供者将一些特定的应用程序数据供给其它应用程序使用,它主要作用是用来在多个APP之间共享数据,如腾讯QQ中的QQ电话功能需要获取用户手机上的联系人的手机号码,还算不上标准的多个APP之间的消息通信(因为共享数据只是消息通信中很小的一部分)。共享的数据可以存储于文件系统、SQLite数据库或其它方式。内容提供者继承于ContentProvider 基类,为其它应用程序取用和存储它管理的数据实现了一套标准方法。然而,应用程序并不直接调用这些方法,而是使用一个 ContentResolver 对象,调用它的方法作为替代。ContentResolver可以与任意内容提供者进行会话,与其合作来对所有相关交互通讯进行管理。

    无论数据的来源是什么,ContentProvider都会认为是一种表,然后把数据组织成表格形式,因此该类提供给我们的方法类似于sqlite数据库中的增删改查的操作。

    要使用ContentProvider我们需要先来了解一个概念URI。

    1 URI(统一资源标识符(Uniform Resource Identifier))用来唯一的标识一个资源。在上述我说过ContentProvider是用来在多个APP之间共享数据的,那么首先我们得找到这个数据,这个资源(数据属于资源的一种)是采用URI来标识的。它包括三个部分:scheme authority and path,其中在安卓中共ContentProvider访问的scheme固定值为:content://(就像Http协议固定值为http://),authority包括host和port。

    scheme:标准前缀,用来说明一个Content Provider控制这些数据,无法改变的;"content://"

    authority:URI 的标识,用于唯一标识这个ContentProvider,外部调用者可以根据这个标识来找到它。它定义了是哪个Content Provider提供这些数据。对于第三方应用程序,为了保证URI标识的唯一性,它必须是一个完整的、小写的类名。这个标识在 元素的 authorities属性中说明:一般是定义该ContentProvider的包.类的名称

    path:路径(path),通俗的讲就是你要操作的数据库中表的名字,或者你也可以自己定义,记得在使用的时候保持一致就可以了;"content://com.bing.provider.myprovider/tablename"

    如果URI中包含表示需要获取的记录的ID(数据以表的形式表示),则就返回该id对应的数据,如果没有ID,就表示返回全部

    要操作的数据不一定来自数据库,也可以是文件、xml或网络等其他存储方式,如要操作xml文件中person节点下的name节点,可以构建这样的路径:/person/name
    如果要把一个字符串转换成Uri,可以使用Uri类中的parse()方法,如下:Uri uri = Uri.parse("content://com.demo.provider.personprovider/person");

    2ContentProvider共享数据

    我们先来看一下ContentProvider(ContentProvider为一个抽象类)的重要方法:

      public abstract boolean onCreate();
    
     public abstract Cursor query(Uri uri, String[] projection,
                String selection, String[] selectionArgs, String sortOrder);
    
     public Cursor query(Uri uri, String[] projection,
                String selection, String[] selectionArgs, String sortOrder,
                CancellationSignal cancellationSignal) {
            return query(uri, projection, selection, selectionArgs, sortOrder);
        }
    
      public abstract String getType(Uri uri);
      public abstract Uri insert(Uri uri, ContentValues values);
      public abstract int delete(Uri uri, String selection, String[] selectionArgs);
      public abstract int update(Uri uri, ContentValues values, String selection,
                String[] selectionArgs);
    可以看到ContentProvider中的增删改查这些重要的方法都是抽象的,因此当我们继承自该类时需要重写其抽象方法。

    3ContentResolver来操作数据

    当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时,需要使用ContentResolver类来完成,要获取ContentResolver对象,可以使用Context提供的getContentResolver()方法(即该方法位于Context类中)。

    ContentResolver cr = getContentResolver();

    ContentProvider负责组织应用程序的数据,向其他应用程序提供数据,ContentResolver则负责获取ContentProvider提供的数据。因此可以知道ContentResolver中也因该存在增删改查的接口。

     public final Cursor query(Uri uri, String[] projection,
                String selection, String[] selectionArgs, String sortOrder) {
            return query(uri, projection, selection, selectionArgs, sortOrder, null);
        }
      public final Uri insert(Uri url, ContentValues values)
      public final int delete(Uri url, String where, String[] selectionArgs)
    
      public final int update(Uri uri, ContentValues values, String where,
                String[] selectionArgs)
    
      public final String getType(Uri url)

    可以看到在ContentResolver中存在于ContentProvider相对应的增删改查的方法接口,而且这些方法都是final修饰的,另外这些方法的第一个参数为Uri,代表要操作的ContentProvider(通常用包名+类名表示)和对其中的什么数据(通常是以表形式存储的)进行操作。代码如下:

    ContentResolver resolver =  getContentResolver();//首先获取ContentResolver对象
    Uri uri = Uri.parse("content://com.demo.provider.personprovider/person");//定义要访问的ContentProvider的RUI
    //添加一条记录
    ContentValues values = new ContentValues();
    values.put("name", "htq");
    values.put("age", 20);
    resolver.insert(uri, values);  
    
    //获取person表中所有记录
    Cursor cursor = resolver.query(uri, null, null, null, "personid desc");
    while(cursor.moveToNext()){
       Log.i("ContentTest", "personid="+ cursor.getInt(0)+ ",name="+ cursor.getString(1));
    }
    
    //把id为1的记录的name字段值更改新为zhangsan
    ContentValues updateValues = new ContentValues();
    updateValues.put("name", "zhangsan");
    Uri updateIdUri = ContentUris.withAppendedId(uri, 2);
    resolver.update(updateIdUri, updateValues, null, null);
    
    //删除id为2的记录
    Uri deleteIdUri = ContentUris.withAppendedId(uri, 2);
    resolver.delete(deleteIdUri, null, null);
    

    使用文件或云端方式共享

    使用文件就是把数据以文件的形式保存,然后提供一定的访问权限供其它APP访问,云端共享与此类似只不过存储位置位于云端而已,云端共享最典型的莫过于搜索引擎与云盘共享。


    使用BroadcastReceiver

    上述介绍的几种方式算不上完完全全的APP之间的消息通信,因为上述仅仅是多个APP之间共享数据而已,而在安卓中广播机制就是用来在多个APP之间通信的较好的方式,如多个APP可以响应系统网络监听的广播。一般广播的工作流程如下:

    1.广播接收者BroadcastReceiver通过Binder机制向AMS(Activity Manager Service)进行注册;

    2.广播发送者通过binder机制向AMS发送广播;

    3.AMS查找符合相应条件(IntentFilter/Permission等)的BroadcastReceiver,将广播发送到BroadcastReceiver(一般情况下是Activity)相应的消息循环队列中;

    4.消息循环执行拿到此广播,回调BroadcastReceiver中的onReceive()方法。

    一般广播的使用流程如下:

    1定义一个子类继承自抽象的BroadcastReceiver类,重写其抽象的onReceive(Context context, Intent intent)方法,当广播接收者收到广播会自动回调该方法。

    2注册/注销该广播:通过intentFilter.addAction(Constants.ACTION_MSG);来指定注册的广播对哪种广播消息进行响应

    3在另一个组件中使用intent.setAction(Constants.ACTION_MSG); sendBroadcast(intent);来指定发送的广播类型,如果要传递数据可以使用intent.putExtra(Constants.MSG, msg);

    如在BaseActivity中响应ACTION_MSG,在getMsgService中发送ACTION_MSG的广播,代码如下:

    //接受广播的BaseActivity类
    public abstract class BaseActivity extends Activity {
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    	}
    	protected void onStart() {
    		// TODO Auto-generated method stub
    		super.onStart();
    		IntentFilter intentFilter=new IntentFilter();
    		intentFilter.addAction(Constants.ACTION_MSG);//指定响应<span style="font-family: Arial, Helvetica, sans-serif;">Constants.ACTION_MSG)的广播</span>
    
    		registerReceiver(MsgReceiver, intentFilter);//注册广播
    	}
    
    	@Override
    	protected void onStop() {
    		// TODO Auto-generated method stub
    		super.onStop();
    		
    		unregisterReceiver(MsgReceiver);
    	}
    	BroadcastReceiver MsgReceiver=new BroadcastReceiver()//定义一个类继承自抽象的BroadcastReceiver类,此处采用的是匿名类的方式
    	{
    
    		@Override
    		public void onReceive(Context context, Intent intent) {//重写抽象的onReceive(Context context, Intent intent)方法
    			// TODO Auto-generated method stub
    			TransportObject msg=(TransportObject)intent.getSerializableExtra(Constants.MSG);
    			getMessage(msg);
    			
    		}};
    	protected abstract void getMessage(TransportObject msg);
    
    }
    
    //发送广播的getMsgService类
    public class GetMsgService extends Service {
    	...
    
    	@Override
    	public void onStart(Intent intent, int startId) {
    		new Thread(){
    			   public void run()
    			   {
    				...					
    				if(isStart)
    				{
    					cit=client.getClientInputThread();
    					if(cit!=null)
    					{
    						cit.setMessageListener(new MessageListener() {
    							
    							public void getMessage(TransportObject msg) {
    								
    								if(msg!=null&&msg instanceof TransportObject)
    								{
    									//通过广播向Activity传递消息
    									Intent intent=new Intent();
    									intent.setAction(Constants.ACTION_MSG);
    									intent.putExtra(Constants.MSG, msg);//通过广播传递数据
    								        sendBroadcast(intent);
    								}
    							}
    						});
    					}
    					else {
    						Log.i("GetMsgService","服务器端连接暂时出错");
    					//	Toast.makeText(getApplicationContext(), "服务器端连接暂时出错,请稍后重试!",0).show();
    					}
    				}
    				   
    			   }
    		   }.start();
    	}
    
    	...
    
    }
    
    虽然上述的代码是在同一个APP中响应的该广播,但是如果多个APP中的广播注册时使用Constants.ACTION_MSG字符串指定的广播则getMsgService类中sendBroadcast时多个APP的广播可以响应。


    四使用AIDL让多个APP与同一个Service通信

    AIDL(Android Interface definition language),在Android中,每个应用运行在属于自己的进程中,无法直接调用到其他应用的资源,那么当多个APP之间相互通信的话,那么自然就转化为IPC机制了,而AIDL就是安卓系统中用来实现IPC机制的。那么哪些场合需要使用AIDL呢,安卓官方文档上说的很清楚:

    Using AIDL is necessary only if you allow clients from different applications to access your service for IPC and want to handle multithreading in your service. If you do not need to perform concurrent IPC across different applications, you should create your interface by implementing a Binder or, if you want to perform IPC, but do not need to handle multithreading, implement your interface using a Messenger. Regardless, be sure that you understand Bound Services before implementing an AIDL.

    通过上述文档叙述可以看到,当需要在不同APP之间访问同一个服务且处理多线程的时候需要用到AIDL,如果不是多个APP之间的IPC只需使用Binder机制,如果需要处理不同APP之间但是只是单线程的话只需使用Messager机制,即下面将介绍的一类情况。所以可以知道AIDL最佳使用情况是在不同APP之间访问同一个服务且处理多线程,因此可以知道AIDL可以用来处理不同APP之间的通信。

    AIDL的使用:

    一服务端:

    1定义AIDL文件(该文件是一个接口,文件中的方法全部为抽象方法,如果格式正确,IDE会自动在gen目录下生成对应的java文件)

    interface MyAIDL {
    	int plus(int a, int b);
    }

    2定义服务类(AIDL就是用来在多个APP之间访问同一个service的),在该服务类中定义对应的stub对象,在该stub对象中实现上述AIDL文件中定义的抽象方法,在服务的onBind(Intent intent)中返回该stub对象。AndroidManifest.xml配置相关属性。

    public class MyService extends Service {
    
    	......
    
    	@Override
    	public IBinder onBind(Intent intent) {
    		return mBinder;//在onBind中返回该stub对象
    	}
    
    	DemoAIDL.Stub mBinder = new Stub() {//在服务类中定义对应的stub对象,实现aidl中定义的抽象方法
    
    		@Override
    		public int plus(int a, int b) throws RemoteException {
    			return a + b;
    		}
    	};
    
    }

    AndroidManifest.xml配置相关属性如下:

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.servicetest"
        android:versionCode="1"
        android:versionName="1.0" >
        ......

        <service
            android:name="com.example.servicetest.MyService"
            android:process=":remote" >
            <intent-filter>
                <action android:name="com.example.servicetest.MyAIDLService"/>//注意action的android:name属性,该属性在客户端bindService中将会用到
            </intent-filter>
        </service>


    </manifest>

    上述定义服务的APP相当于服务端。

    二客户端:

    1我们只需要把服务端aidl文件拷到相应的目录中即可,IDE会自动生成相对应的java文件,这一部分和服务端相同,这样服务端和客户端就在通信协议上达到了统一。

    2在客户端的Activity中与Service通信,在客户端的Activity中定义ServiceConnection类,在该类的onServiceConnected(ComponentName name, IBinder service)方法中通过xxx.Stub.asInterface(service);获取定义的AIDL文件生成的java类,(xxx为aidl文件自动生成的对应的java文件类名),使用bindService(intent, conn,Context.BIND_AUTO_CREATE);来绑定远程服务,注意此时的intent需要指定为我们在服务端创建的service的name属性。

    <pre name="code" class="java">public class MainActivity extends Activity implements OnClickListener {
    
    
    	...
    	private MyAIDL myAIDL;
    
    	private ServiceConnection connection = new ServiceConnection() {
    
    		@Override
    		public void onServiceDisconnected(ComponentName name) {
    		}
    
    		@Override
    		public void onServiceConnected(ComponentName name, IBinder service) {
    			myAIDL = MyAIDL.Stub.asInterface(service);//在onServiceConnected中将IBinder转换为aidl对应的java类
    			try {
    				int result = myAIDL.plus(3, 5);
    				Log.d("TAG", "result is " + result);
    			} catch (RemoteException e) {
    				e.printStackTrace();
    			}
    		}
    	};
    protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_main);
    		Button bindService = (Button) findViewById(R.id.bind_service);
    		bindService.setOnClickListener(new OnClickListener() {
    		@Override
    		public void onClick(View v) {
    		   Intent intent = new Intent("com.example.servicetest.MyAIDLService");//intent指定为我们在服务端创建的service的intent-filter中action的android:name属性。
    		   bindService(intent, connection, BIND_AUTO_CREATE);
    		}
    	     });
    	}
    
    }

    
    

    五使用Messager

    Messager实现IPC通信,底层也是使用了AIDL方式。和AIDL方式不同的是,Messager方式是利用Handler形式处理,因此,它是线程安全的,这也表示它不支持多线程处理;而AIDL方式是非线程安全的,支持多线程处理,因此,我们使用AIDL方式时需要保证代码的线程安全。

    首先我们来看一下其构造函数:

        public Messenger(Handler target) {
            mTarget = target.getIMessenger();  
        }
    可以看到Messenger的构造函数中的参数为Handler对象,Messager本质上就是跨进程使用Handler。

    Messenger使用步骤:

    客户端绑定服务端,在ServiceConnection类的onServiceConnection方法中将远程服务端传过来的binder对象转换为Messenger对象,调用Messenger的send函数,就可以把Message发送至服务端的Handler。同时,如果需要服务端回调客户端(往客户端的Handler发消息),则可以在send的Message中设置replyTo,服务端就可以往客户端发送消息了。

    客户端代码:

    public class MainActivity extends Activity {
      
        protected static final String TAG = "MainActivity";
        Messenger messenger;
        Messenger reply;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            reply = new Messenger(handler);
            Intent intent = new Intent("<span style="line-height: 25.2px; font-family: Verdana, Arial, Helvetica, sans-serif;">test.messenger.MessengerTestService</span><span style="line-height: 25.2px; font-family: Verdana, Arial, Helvetica, sans-serif;">");</span>
            // 绑定服务
            bindService(intent, new ServiceConnection() {
                @Override
                public void onServiceDisconnected(ComponentName name) {
                }
                @Override
                public void onServiceConnected(ComponentName name, IBinder service) {
                    Toast.makeText(MainActivity.this, "bind success", 0).show();
                    messenger = new Messenger(service);//将远程服务端中返回的IBinder对象转换为Messenger对象
                }
            }, Context.BIND_AUTO_CREATE);      
        }
        public void sendMessage(View v) {
            Message msg = Message.obtain(null, 1);
            // 设置回调用的Messenger
            msg.replyTo = reply;//<span style="font-family: Verdana, Arial, Helvetica, sans-serif;font-size:12px; line-height: 25.2px;">如果需要服务端回调客户端,<span style="font-family: Verdana, Arial, Helvetica, sans-serif;font-size:12px; line-height: 25.2px;">则可以在send的Message中设置replyTo,将客户端的Messenger传递给服务端</span></span>
            try {
                messenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        private Handler handler = new Handler() {//回调Messenger处理的Handler
            @Override
            public void handleMessage(Message msg) {
                Log.d(TAG, "回调成功");
            }
        };
    }
    服务端通过Message的replyTo取出客户端传递过来的Messenger,这样就可以通过该Messenger与客户端通信。

    服务端通过Messenger的getBinder方法将IBinder对象返给客户端,用于共享服务端的Messenger。
    服务端代码:

    public class MessengerTestService extends Service {
        protected static final String TAG = "MessengerTestService";
        private Handler mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                case 1:
                    Log.d(TAG, "收到消息");
                     //获取客户端message中的Messenger,用于回调
                    final Messenger callback = msg.replyTo;
                    try {
                        // 回调
                        callback.send(Message.obtain(null, 0));
                    } catch (RemoteException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    break;
                }
            }
        };
        @Override
        public IBinder onBind(Intent intent) {
            return new Messenger(mHandler).getBinder();//在onBind(Intent intent)方法中返回Messenger对应的binder对象。
        }
    }
    可以看到该方式与用AIDL方式整体大的框架基本相同,都是在远程服务端的Service中的onBind(Intent intent)中返回Ibinder对象,在客户端的ServiceConnection类的onServiceConnectioned(ComponentName name, IBinder service)中奖Ibinder转换为对应的对象,在AIDL中通过xxx.Stub.asInterface(service);转换为对应的aidl的java类,在Messenger中通过messenger = new Messenger(service);转换为Messenger对象,然后利用这个对象就可相互通信。

    展开全文
  • 通过props可以实现父向子通信通过$emit可以实现子向父通信,现在我要介绍另外一种方式,通过props传对象的形式通信。 首先写一个简单的例子 //父组件 parent> input type="text" v-model="parent.name" /> ...
  • C++对象之间通信的三种常见方式

    万次阅读 2017-11-03 18:53:19
    经过这一年多对C++的使用,总结出了下边的三种常见对象之间通信方式。这里就不上代码了。只作为一种设计思想,记录下来方便自已以后使用,和大家一起学习,这只是自已在工作中的总结,如果谁有更好的经验,请回复...
  • 专栏 >实现游戏对象与对象之间通信

    千次阅读 2012-08-06 02:21:46
    游戏中,对象与对象之间需要交流,实现的方法多种,例如:可定义静态变量,其他脚本直接调用, 也可用到: SendMessage 今天主要学习SendMessage的用法。   1、创建两个脚本:“Cube0”和“Cube1”; 2、将两个...
  • 关于对象之间通信的一点思考

    千次阅读 2012-08-07 01:33:04
    关于对象之间通信的一点思考 1. 经典的DDD的告诉我们如果一个领域概念是一个跨多个聚合的动作,比如转帐,那么就应该用领域服务来实现这样的业务概念。领域服务的输入和输出参数都是聚合根,领域服务内部...
  • 面向对象基本概念

    万次阅读 多人点赞 2019-02-06 21:56:15
    通过一个简单的外部接口与外界发生关系,对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念,人们每天都要接触各种各样的对象,如手机就是一个对象。 面向...
  • QT信号和槽用于对象之间通信

    千次阅读 2016-03-05 10:41:10
    更一般地,我们希望任何一类的对象可以和其它对象进行通讯。例如,如 果我们正在解析一个XML文件,当我们遇到一个新的标签时,我们也许希望通知列表 视图我们正在用来表达XML文件的结构。 较老的工具包
  • 闲话少说正题如下:本人在开发过程中曾经碰过一个疑惑:面向对象开发时候在类之间通信如何做?1:如果把所有的需要参数都通过结构指针传过去那么需要调用类的一些功能函数如何处理?2:我就写个全局变量吧,爱什么数据就...
  • 在iIOS 中 delegate 主要用于视图与使用对象之间通信交互,典型的特点就是它有返回值。 用途:常用于传\赋值(如tableView中的委托(dateSource)中常见)或者传递事件(例如在异步请求中,界面事件触发数据层改变...
  • 串行通信实现的是两个对象之间的数据传递,对象通常是单片机。通信实际上是在两个单片机上连上线,通过线路来传递信息。 如图,调制解调器非常重要,其作用是实现数字信号和模拟信号的转换。但是注意,调制解
  • IPC(Inter-Process Communication) :指进程间通信 ,指至少两个进程或线程间...不单单是进程与进程之间可以用AIDL,Service和组件之间不但可以用Messenger来通信,也可以用AIDL来通信。使用Messenger更简单,核心是
  • UML(二)——面向对象的基本概念

    千次阅读 2015-08-31 10:52:59
    对象之间通过消息进行通信。对象总是处于一定的状态。对象有若干种行为,分为三类:创建新对象,与其他对象通信,改变自身状态。对象的状态只能被自身的行为所改变。某个对象的状态可以又多个其他对象的状态构成。 ...
  • 下面这个程序演示了多个线程之间进行通信的具体实现过程。程序中用到了4个类,其中ShareData类用来定义共享数据和同步方法。在同步方法中调用了wait()方法和notify()方法,并通过一个信号量来实现线程间的消息传递。...
  • 进程之间通信方式 (1) 管道(PIPE) (2) 命名管道(FIFO) (3) 信号量(Semphore) (4) 消息队列(MessageQueue) (5) 共享内存(SharedMemory) (6) Socket Java如何支持进程间通信。我们把Java进程理解为JVM进程。很明显,...
  • 碎片和活动之间进行通信 虽然碎片都是嵌入在活动中显示的,可是实际上它们的关系并没有那么亲密。你可以看 出,碎片和活动都是各自存在于一个独立的类当中的,它们之间并没有那么明显的方式来直 接进行通信。如果...
  • 网友佚名写的文章对其进行了详细的说明,见《Vs2003多窗口下的复杂数据传递》一文:http://www.cnblogs.com/xxm/archive/2006/07/01/440392.html 相信大家如果理解了上面这篇文章,也就会用委托进行对象间的通信了...
  • #产生两个返回对象,一个是管道这一头,一个是另一头 p = Process(target=f,args=(child_conn,)) p.start() print(parent_conn.recv()) print(parent_conn.recv()) parent_conn.send( 'father test' ) p.join...
  • Activity之间通信

    万次阅读 2015-06-26 17:23:10
    向下一个Activity对象传递数据 向上一个Activity返回数据 Intent传递自定义对象等等
  • 计算机之间是如何实现通信

    千次阅读 2020-02-26 19:26:27
    所谓的计算机网络简单来说就是指通过某一种方式将多台计算机进行连接并实现计算机彼此之间的互联和数据交换。 在计算机网络中,计算机之间要实现连接和通信,就需要遵守一定的规则,我们把这种连接...
  • Activity和Service之间通信方式有多种:通过broadcast、扩展Binder类、使用Messenger、使用AIDL等。 扩展Binder类使用场景 如果你的服务仅供本地应用使用,不需要跨进程工作,则可以实现扩展Binder 类,让你的...
  • 两个Activity之间用接口回调进行通信

    千次阅读 2017-03-22 09:09:51
    因为刚接触的一个项目是蓝牙连接,需求是要在扫描界面点击...但是我之前写接口回调没有在两个activity之间进行过接口回调,所以就自己想了下写了下面一段代码. 先定义一个接口:public interface ConnectionStateListener
  • java之服务器端和客户端之间简单的通信

    千次阅读 多人点赞 2018-05-13 17:04:48
    java之服务器端和客户端之间简单的通信 最近因为作业的需要,老师让用java语言写一个关于服务器端和客户端之间简单的通信,所以就有了这一篇文章 准备工作: 博主是在eclipse工具下进行操作的。 程序代码如下所...
  • 不同项目之间通信

    千次阅读 2017-05-20 14:44:31
    不同项目之间通信方式分为,http、socket、webservice;其中socket通信的效率最高,...前者通过Http消息实体发送数据给服务器,安全性高,数据传输大小没有限制,后者通过URL的查询字符串传递给服务器参数,以明文显
  • 进程之间通信方式

    千次阅读 2018-07-09 22:00:33
    https://www.cnblogs.com/edisonchou/p/5022508.html进程之间有直接通信和间接通信两种方式。有管道、信号、消息队列、共享内存、socket、信号量。...信号可以直接进行用户空间进程和内核进程之间的交互,内核进程...
  • angularjs controller之间通信

    千次阅读 2015-03-10 16:05:32
    接触了angularjs有一段时间了,最近遇到一个问题,需要在controller之间进行通信,当初想了一下,并不是很难,angularjs不是有个rootscope吗, 于是我就在其中一个controller里面写了一个function,然后赋值给...
  • Fragment之间通信很简单……这里只是提供思路,无论是Fragment和Activity还是Fragment之间,通信的原理都是如此,所以Fragment之间通信不能直接通信,必须依靠所依附的Activity。 可以通过getSupportFragmentManager...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 441,108
精华内容 176,443
关键字:

对象之间通过消息进行通信