android 瑟维斯(Service)(Service) 学习统计起名

再度运行程序,在MainActivity界面点击按钮成功启动SecondActivity这些倒。

亚、Service(Service) 与 Thread 之间的干

  Service(Service)以及Thread这半单凡是没啊关联之。因为大家了然瑟维斯(Service)(Service)是运作于UI线程中,那么当需要耗时操作的早晚,就得Thread扶助,不是说Service(Service)因为凡在后台运行,就同Thread等和了。Thread是用于开启一个子线程,在此处失去实施有耗时操作就未会见卡住主线程的运转。而瑟维斯(Service)大家早期知道的时段,总会当她是用来拍卖部分后台任务的,一些较耗时的操作也得在此处运行,这便相会被人有模糊了。

  Android的后台就是据,它的运作是一心无依赖UI的。尽管Activity被销毁,或者程序让关闭,只要经过还于,瑟维斯(Service)就足以连续运行。比如说有的应用程序,始终用与服务器之间始终保正心跳连接,就好选择Service(Service)来实现。

  大家得在瑟维斯(Service)中重新创一个子线程,然后于那边去处理耗时逻辑就是从未有过问题。既然在Service里假若创一个子线程,这怎么非直接当Activity里成立为?这是以Activity很为难对Thread举行支配,当Activity被灭绝后,就不曾其余其余的主意可以再度还取得到事先成立的子线程的实例。而且于一个Activity中创立的子线程,另一个Activity无法对其展开操作。可是瑟维斯(Service)(Service)就差了,所有的Activity都可以和瑟维斯(Service)进行关联,然后可以相当有益地操作中的措施,固然Activity被灭绝了,之后要再与瑟维斯(Service)(Service)建立关系,就又能获取到原的瑟维斯(Service)(Service)中Binder的实例。因而,使用瑟维斯(Service)(Service)来处理后台任务,Activity就可以放心地finish,完全无待操心不可以对后台任务举办支配的情。

 当需要以一个瑟维斯(Service)中开创一个子线程时,可以经过如下实现:

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 开始执行后台任务
        }
    }).start();
    return super.onStartCommand(intent, flags, startId);
}

class MyBinder extends Binder {

    public void startDownload() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 执行具体的下载任务
            }
        }).start();
    }

}

1、使用显式Intent

  学习android开发已四三只月,由于项目遭到职责的由一贯没点过Service的实在项目,今日更学一举瑟维斯(Service)用法。

 2.1应用隐式Intent,也堪启动其他程序的移位,比方调用系统的浏览器来开辟网页。

1.1 瑟维斯(Service)(Service) 生命周期 及两栽状态

起名 1

  瑟维斯(Service)(Service) 分为两栽工作状态: 一种植是 启动状态用于实施后台统计,另一样种是
绑定状态用于和此外零件和瑟维斯(Service)举办交互。需要留意的是就简单种状态的Service是可存活之,即Service(Service)既可处绑定状态和开行状态。

start瑟维斯(Service)(Service)()启动的生命周期:

  当我们率先潮采取startService启动一个劳动平日,系统实例化一个瑟维斯(Service)(Service)实例,然后逐一调用onCreate()和onStartCommand()方法,然后运行,需要注意的是,再也利用start瑟维斯(Service)方法时,不汇合在创制一个新的服务目的了,但要么会更实施onStartCommand()方法,假如大家怀恋使适可而止少一个劳动,可以就此stopService方法,此时,onDestroy()方法就会被调用,不管前边使用了略微次的start瑟维斯(Service)(Service),stop瑟维斯(Service)(Service)方法调用一糟,就然而止少服务。

 自定义一个 My瑟维斯(Service)继承自Service(Service) 

起名 2起名 3

public class MyService extends Service {

    public static final String TAG = "MyService";

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() executed");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() executed");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy() executed");
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

}

View Code

当全国startService(Service)()启动一个Service时

Intent startIntent = new Intent(this, MyService.class);  
startService(startIntent);  

log音信如下:

起名 4

复启航Service(Service)时: 

起名 5

调用stopService(Service)()时,瑟维斯(Service)就会晤为终止。

Intent stopIntent = new Intent(this, MyService.class);  
stopService(stopIntent);  

这种艺术瑟维斯(Service)和Activity的干并无坏,只是Activity通告了Service一下:“你可启动了。”然后Service就失忙自己之业务了

bindService()启动之生命周期:

  当调用者首不佳采取bindService(Service)绑定一个劳务平常,系统会实例化一个Service实例,并同样不良调动用其onCreate()方法及onBind()方法,然后调用者就得跟劳务拓展互相了,此后,假使还用bindService(Service)绑定服务,系统非会面立异的Service(Service)实例,也无会师再次调用onBind方法;倘使我们得免去以及那服务的绑定,可使用unbindService方法,此时onUnbind方法与onDestroy方法会叫调用。

自定义Service;

public class MyService extends Service {

    public static final String TAG = "MyService";

    private MyBinder mBinder = new MyBinder();

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() executed");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() executed");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy() executed");
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    class MyBinder extends Binder {

        public void startDownload() {
            Log.d("TAG", "startDownload() executed");
            // 执行具体的下载任务
        }

    }

}

  这里我们新增了一个MyBinder类继承自Binder类,然后以MyBinder中上加了一个startDownload()方法用于在后台执行下载任务,当然这里并无是真地失去下载某东西,只是做只测试,所以startDownload()方法就是打印了一样实施日志。

于MainActivity中开同倒闭Service:

public class MainActivity extends Activity implements OnClickListener {

    private Button startService;

    private Button stopService;

    private Button bindService;

    private Button unbindService;

    private MyService.MyBinder myBinder;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myBinder = (MyService.MyBinder) service;
            myBinder.startDownload();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        startService = (Button) findViewById(R.id.start_service);
        stopService = (Button) findViewById(R.id.stop_service);
        bindService = (Button) findViewById(R.id.bind_service);
        unbindService = (Button) findViewById(R.id.unbind_service);
        startService.setOnClickListener(this);
        stopService.setOnClickListener(this);
        bindService.setOnClickListener(this);
        unbindService.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.start_service:
            Intent startIntent = new Intent(this, MyService.class);
            startService(startIntent);
            break;
        case R.id.stop_service:
            Intent stopIntent = new Intent(this, MyService.class);
            stopService(stopIntent);
            break;
        case R.id.bind_service:
            Intent bindIntent = new Intent(this, MyService.class);
            bindService(bindIntent, connection, BIND_AUTO_CREATE);
            break;
        case R.id.unbind_service:
            unbindService(connection);
            break;
        default:
            break;
        }
    }

}

  能够望,这里咱们率先创设了一个ServiceConnection的匿名类,在其间还写了on瑟维斯(Service)Connected()方法以及on瑟维斯(Service)(Service)Disconnected()方法,这半个章程分别会师在Activity与瑟维斯(Service)建立涉和扫除关系的上调用。在onServiceConnected()方法吃,大家以经过奔下转型取得了MyBinder的实例,有了那多少个实例,Activity和Service(Service)之间的涉就是换得杀连贯了。现在我们得当Activity中冲具体的面貌来调用MyBinder中的别样public方法,即实现了Activity指挥瑟维斯(Service)干什么瑟维斯(Service)(Service)就失去干啊的效能。 

改MainActivity中按钮的点击事件,代码如下:

    如何兑现同Activity之间的通信?

改MainActivity中按钮点击事件之代码,如下:

4.1 开启service的Server端程序

  下边大家就来一步步地圈一下AIDL底用法到底是怎么着的。首先得新建一个AIDL文件,在是文件被定义好Activity需要和瑟维斯(Service)进行通信的措施。新建MyAIDL瑟维斯(Service).aidl文件,代码如下所示:(点击sync后,会生成MyAIDL瑟维斯(Service).java文件)

package com.example.servicetest;
interface MyAIDLService {
    int plus(int a, int b);
    String toUpperCase(String str);
}

然后修改My瑟维斯(Service)中之代码,在内部实现大家正好定义好的MyAIDLService(Service)接口,如下所示:

public class MyService extends Service {

    ......

    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    MyAIDLService.Stub mBinder = new Stub() {

        @Override
        public String toUpperCase(String str) throws RemoteException {
            if (str != null) {
                return str.toUpperCase();
            }
            return null;
        }

        @Override
        public int plus(int a, int b) throws RemoteException {
            return a + b;
        }
    };

}

  这里首先针对MyAIDL瑟维斯(Service)(Service).Stub举行了贯彻,重写里了toUpperCase()和plus()这简单只点子。这一点儿独主意的效用分别是将一个字符串全部转移成这多少个写格式,以及将鲜单传入的平头举办相加。然后在onBind()方法校官MyAIDL瑟维斯(Service).Stub的贯彻重回。这里怎么可以如此勾画为?因为Stub其实就是Binder的子类,所以在onBind()方法被得以一贯归Stub的兑现。

public class MainActivity extends Activity implements OnClickListener {

    private Button startService;

    private Button stopService;

    private Button bindService;

    private Button unbindService;

    private MyAIDLService myAIDLService;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myAIDLService = MyAIDLService.Stub.asInterface(service);
            try {
                int result = myAIDLService.plus(3, 5);
                String upperStr = myAIDLService.toUpperCase("hello world");
                Log.d("TAG", "result is " + result);
                Log.d("TAG", "upperStr is " + upperStr);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    ......

}

  可以看来,这里首先应用了MyAIDLService.Stub.asInterface()方法以盛传的IBinder对象传换成了MyAIDL瑟维斯(Service)对象,接下就是可调用在MyAIDL瑟维斯(Service)(Service).aidl文件被定义的具有接口了。这里我们先是调用了plus()方法,并传播了3以及5当做参数,然后以调用了toUpperCase()方法,并传到hello
world字符串作为参数,最后将调用方法的归咎果打印出来。

总之,大家实在都打响落实跨进程通信了,在一个过程被做客到了此外一个进程中之章程。

 

  不过你吧足以看来,近来的越进程通信其实并不曾啊实质上的意向,因为这无非是于一个Activity里调用了与一个应用程序的Service里的方法。而超进程通信的的确含义是为让一个应用程序去拜谒另一个应用程序中之瑟维斯(Service),以贯彻共享Service的机能。那么下大家本要学习一下,怎样才会以任何的应用程序中调用到My瑟维斯(Service)里的章程。

 

一旦想即便吃Activity与瑟维斯(Service)(Service)之间确立涉,需要调用bind瑟维斯(Service)()方法,并将Intent作为参数传递进去,在Intent里指定好而绑定的瑟维斯(Service)(Service),示例代码如下:

Intent bindIntent = new Intent(this, MyService.class);  
bindService(bindIntent, connection, BIND_AUTO_CREATE);  

注册Service(让其他程序可以经过隐式方法访问该瑟维斯)

<service  
        android:name="com.example.servicetest.MyService"  
        android:process=":remote" >  
        <intent-filter>  
            <action android:name="com.example.servicetest.MyAIDLService"/>  
        </intent-filter>  
    </service>  

流动:android 5.0 之后隐式方法访问瑟维斯(Service)需要: 

  Intent intent = new
Intent(“com.example.servicetest.MyAIDLService”).setPackage(com.example.servicetest);

及是,Server端的
service就定义好了,他得在该server端的次中运作,另外程序也可看该瑟维斯(Service)(Service)

修改安卓入门1备受的MainActivity中的按钮点击事件,在MainActivity那些运动之根底及开拓SecondActivity这多少个活动,代码如下:

1.2 同时startService和binderService

  如若大家既然点击了StartService按钮,又点击了Bind
Service(Service)按钮会怎么样也?这么些时段你会意识,不管你是单独点击Stop
瑟维斯(Service)(Service)按钮如故Unbind
Service按钮,Service(Service)都未汇合受灭绝,必要将鲜单按钮都点击一下,Service才会叫销毁。也就是说,点击Stop
瑟维斯(Service)(Service)按钮只会合让Service(Service)截至,点击Unbind
Service(Service)按钮只会为Service和Activity解除关系,一个Service(Service)必须要在既没和任何Activity关联而处理截至状态的早晚才会晤给灭绝。

  先点击一下Start 瑟维斯(Service)(Service)按钮,再点击一下Bind
瑟维斯(Service)(Service)按钮,这样就是将瑟维斯(Service)(Service)启动起来,并和Activity建立了涉。然后点击Stop
Service按钮后瑟维斯(Service)(Service)并无会晤销毁,再点击一下Unbind
Service按钮,瑟维斯(Service)就相会销毁了,打印日志如下所示:

起名 6

 

总结:

  这一点儿只启动模式的例外,导致生命周期也殊。startService(Service)与调用者没有必然之关联,即调用者截至了协调的生命周期,只要没使stop瑟维斯(Service)方法已这服务,服务按会运作。而bindService(Service)需要发只寄宿的目的,就一定于bind及有宿主中错过,何人绑定了,何人就是倘使担负,负责其的生命周期,从开首至竣工,假使宿主自己的生命周期截止了,bind瑟维斯(Service)模式将优先拿劳动被销毁掉。

  值得注意的少数是,假如调用者首先是先行用startService(Service)情势启动服务,然后再次用bind瑟维斯(Service)模式绑定某个服务来说,一定要先行用unbindService(Service)情势解绑,然后才故stop瑟维斯(Service)(Service)格局销毁服务对象,不然的话,仅仅只是stopService(Service)是不够的,没解绑的目的要于的,就容易造成内存泄露了。

  我们相应一贯记得在Service(Service)的onDestroy()方法里去清理掉这么些不再使用的资源,避免在Service(Service)被销毁后尚谋面有一对不再选拔的目的仍占着内存。

 

基于安卓入门1的始末,继续以ActivityTest项目蒙又创一个移动。右击com.example.administrator.activitytest包->New->Activity->Empty
Activity,会弹来一个开立活动的对话框,将运动命名为SecondActivity,并勾选Generate
Layout File,给布局文件起名为second_layout,不勾选Launcher
Activity选项,然后点击Finish。

    它跟Thread又出何地区别?

 1 <?xml version="1.0" encoding="utf-8"?>
 2 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3     package="com.example.administrator.activitytest">
 4 
 5     <application
 6         android:allowBackup="true"
 7         android:icon="@mipmap/ic_launcher"
 8         android:label="@string/app_name"
 9         android:supportsRtl="true"
10         android:theme="@style/AppTheme">
11         <activity android:name=".MainActivity">
12             <intent-filter>
13                 <action android:name="android.intent.action.MAIN" />
14 
15                 <category android:name="android.intent.category.LAUNCHER" />
16             </intent-filter>
17         </activity>
18         <activity android:name=".SecondActivity"></activity>                //SecondActivity不是主活动,不需要配置<intent-filter>标签里的内容
19     </application>
20 
21 </manifest>

一、Service 介绍

自官网中,我们可见到如此一词:

起名,Most confusion about the Service class actually revolves around what
it is not:

  • A Service is not a separate process. The Service object itself
    does not imply it is running in its own process; unless otherwise
    specified, it runs in the same process as the application it is
    part of.
  • A Service is not a thread. It is not a means itself to do work off
    of the main thread (to avoid Application Not Responding errors).

Thus a Service itself is actually very simple, providing two main
features:

  • A facility for the application to tell the system about something
    it wants to be doing in the background (even when the user is not
    directly interacting with the application). This corresponds to
    calls to Context.startService(), which ask the system to schedule
    work for the service, to be run until the service or someone else
    explicitly stop it.
  • A facility for an application to expose some of its functionality
    to other applications. This corresponds to calls
    to Context.bindService(), which allows a long-standing connection
    to be made to the service in order to interact with it.

  简单的讲,Service不是一个独自的历程,除非她给优异指定,否则其也是咱应用程序的同等部分,它需要依靠让成立服务时所当的应用程序。同时Service(Service)也无是一个线程,她实在是于主线程工作的,所以未可知当瑟维斯(Service)(Service)中拍卖耗时的操作,不然就会师油但是生ARN现象,假若只要处理耗时的操作,能够新起来一个子线程,单独处理。

  更进一步称,瑟维斯(Service)(Service)是
Android中落实程序后台运行的解决方案,它分外适合用于去执行这个不需与用户交互而且还要求老运行的职责。服务之周转无负让其他用户界面,即便当程序为切换至后台,或者用户打开了此外一个应用程序,服务仍可以保持健康运行。

Service有点儿种植启动形式,一种是经过startService()办法,一栽是透过bindService()方,这就半栽具体发生什么界别吗,我们得以看下它们的生命周期来观察端倪。

复运行程序,在MainActivity界面点击按钮成功启动系统浏览器。

其三、 创设前台Service(Service)

  瑟维斯(Service)(Service)几乎都是在后台运行的,一向以来其都是默默地开在劳动的做事。但是瑟维斯(Service)(Service)的网优先级依然相比较小的,当系统出现内存不足情状常,就出或会面回收掉在后台运行的瑟维斯(Service)(Service)。假使你愿意瑟维斯(Service)(Service)可以一贯维系运行状态,而无会见由于系统内存不足的原故致受回收,就好考虑下前台瑟维斯(Service)(Service)。前台瑟维斯(Service)(Service)和一般性瑟维斯(Service)(Service)最酷之分就在,它会直接有一个着运转的图标在网的状态栏呈现,下拉状态栏后可以看看更详细的音讯,非凡接近于通告之效应。当然有时你吧或非可是为以防万一瑟维斯(Service)(Service)被回收才使前台瑟维斯(Service)(Service),有些种类由于特殊的需会要求得运用前台Service,比如说墨迹天气,它的Service在后台更新天气数据的同时,还会见于系状态栏一贯呈现当后日气的音讯。

  那么我们虽来拘禁一下怎么才可以创制一个前台瑟维斯(Service)吧,其实并无复杂,修改MyService(Service)中之代码,如下所示:

public class MyService extends Service {

    public static final String TAG = "MyService";

    private MyBinder mBinder = new MyBinder();

    @Override
    public void onCreate() {
        super.onCreate();
        Notification notification = new Notification(R.drawable.ic_launcher,
                "有通知到来", System.currentTimeMillis());
        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
                notificationIntent, 0);
        notification.setLatestEventInfo(this, "这是通知的标题", "这是通知的内容",
                pendingIntent);
        startForeground(1, notification);
        Log.d(TAG, "onCreate() executed");
    }

    .........

}

  这里只是修改了My瑟维斯(Service)(Service)中onCreate()方法的代码。可以见见,我们先是创立了一个Notification对象,然后调用了她的setLatest伊芙ntInfo()方法来也通知起始化布局及数码,并当这里设置了点击公告后哪怕开辟MainActivity。然后调用startForeground()方法就是可让MyService(Service)变成一个前台Service(Service),并会用通的图形展现出。

1    button1.setOnClickListener(new View.OnClickListener(){
2         @Override
3         public void onClick(View v){
4             Intent intent=new Intent(MainActivity.this,SecondActivity.class);  //第一个参数Context要求提供一个启动活动的上下文,第二个参数Class指定想要启动的目标活动        
5             startActivity(intent);                                             //startActivity()用于启动活动
6         } 
7    });

    具体怎么用?

1  <activity android:name=".SecondActivity">
2       <intent-filter>
3             <action android:name="com.example.administrator.activitytest.ACTION_START"/>
4 
5             <category android:name="android.intent.category.DEFAULT"/>
6       </intent-filter>
7  </activity>

  问题:

AndroidManifest.xml下,在<activity>标签下安排<intent-filter>的情,可以指定当前移动可以响应的action和category。唯有<action>和<category>中的内容而会兼容上Intent中指定的action和category时,那个活动才可以作应该Intent。

    作为四不胜组件,为何用Service?

更运行程序,在MainActivity界面点击按钮成功启动SecondActivity这些活动(打开自己程序外之运动)。

季、远程瑟维斯(Service)(Service)(开辟一个初历程)

 将一个Service放到独的过程面临去实施:

  <service  
        android:name="com.example.servicetest.MyService"  
        android:process=":remote" >  
    </service>  

  这,可以通过start瑟维斯(Service)去开这个瑟维斯(Service)(可以在那瑟维斯(Service)中处理耗时的操作,而未影响主线程的尽,因为它们以任何一个单独的过程被)。不过当大家在MainAcitivity中去bindService时,程序会倒(因为MainActivity在主进程中一旦瑟维斯(Service)运行在中远距离的历程遭到,让MainActivity和My瑟维斯(Service)建立涉会吃程序崩溃)。

  那么什么样干一个Activity与瑟维斯(Service)(Service),这时候需要用AIDL来经过中通信(IPC)

 

  AIDL(Android Interface
Definition
Language)是Android接口定义语言的意思,它可用于为有瑟维斯(Service)与四只应用程序组件之间开展跨进程通信,从而可以兑现四个应用程序共享同一个瑟维斯(Service)的职能。

1    button1.setOnClickListener(new View.OnClickListener(){
2        @Override
3        public void onClick(View v){
4             Intent intent=new Intent("com.example.administrator.activitytest.ACTION_START");
5             startActivity(intent);
6        }
7    });

4.2 访问Service的Client端程序

然后创制一个新的Android项目,起名为ClientTest,我们即使尝试当这些程序中远程调用My瑟维斯(Service)中之措施。

 

ClientTest中的Activity假设想假设同My瑟维斯(Service)建立关联其实呢非麻烦,首先需拿MyAIDLService(Service).aidl文件由Service(Service)Test项目面临拷贝过来,注意要将原本的包路径一起拷贝过来,完成后项目之构造使下图所示:

起名 7

连接下打开或新建MainActivity,在里参加和MyService(Service)建立涉的代码,如下所示:

public class MainActivity extends Activity {

    private MyAIDLService myAIDLService;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myAIDLService = MyAIDLService.Stub.asInterface(service);
            try {
                int result = myAIDLService.plus(50, 50);
                String upperStr = myAIDLService.toUpperCase("comes from ClientTest");
                Log.d("TAG", "result is " + result);
                Log.d("TAG", "upperStr is " + upperStr);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    @Override
    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");
                bindService(intent, connection, BIND_AUTO_CREATE);
            }
        });
    }

}

即刻有代码我们肯定会很熟悉吧?没错,这与当Service(Service)Test的MainActivity中之代码几乎是完全相同的,只是以让Activity和Service建立关联的时候我们下了隐式Intent,将Intent的action指定成了com.example.servicetest.MyAIDL瑟维斯(Service)。

 这样大家跨越进程跨app的通信就得了。

 

参照博客:

http://www.cnblogs.com/cr330326/p/5741464.html

http://blog.csdn.net/guolin\_blog/article/details/11952435/

http://blog.csdn.net/guolin\_blog/article/details/9797169

 

package com.example.servicetest;interface MyAIDLService {int plus(int a,
int b);String toUpperCase(String str);}

2、使用隐式Intent(并无指明我们牵挂使开动哪一个活动,而是指定了扳平雨后春笋更为抽象的action和category等信息,然后到由网去分析这Intent并摸索有确切的倒去启动)

拔取Intent在倒里持续(Intent不仅可以指明当前组件想使履行之动作,仍能不同组件之间传递数据)

1    button1.setOnClickListener(new View.OnClickListener(){
2          @Override
3          public void onClick(View v){
4               Intent intent=new Intent(Intent.ACTION_VIEW);
5               intent.setData(Uri.parse("http://www.baidu.com"));                  //将网址字符串解析为Uri对象,再调用setData()方法将这个Uri对象传递进去
6               startActivity(intent);
7          }
8    });

Android
Studio会自动生成SecondActivity.java和second_layout.xml这有限独公文。在second_layout中上加一个按钮Button
2(步骤同前),SecondActivity中的代码自动生成有,保持默认不换。

AndroidManifest.xml已经报了活动,打开如下:

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图