精华内容
下载资源
问答
  • //如果连接服务成功,则绑定到服务 if(bound) { Log.i("BindService","Successful");} //创建一个message消息并发送给服务端 Message msgFromClient = Message.obtain(null, 0x111,0...
    mainactivity的CODE
    package com.example.servicetosendstatusbarmessage;
    
    import android.annotation.SuppressLint;
    import android.app.Activity;
    import android.app.Notification;
    import android.app.NotificationManager;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.IBinder;
    import android.os.Message;
    import android.os.Messenger;
    import android.os.RemoteException;
    import android.util.Log;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    
    
    public class MainActivity extends Activity{
        private Thread thread;
    	private Button tb,nbs,bs,end;
    	private String title,message,name="新消息";
    	private boolean bound=false;
    	Messenger messenger=null;
    	LocalService myintentService;
    	Intent intent,intent1;
    	private boolean isinteerupt=true,Beginintentservice=false,Beginservice=false;
    	int NOTIFYID_1=1;                          //消息推送码
    	final static int isFromtb=1,isFromwithoutBind=0x11; 
    	Intent intent2;
        NotificationManager notificationManager;
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_main);
    		notificationManager=     //获取通知管理器
    				(NotificationManager)getSystemService(NOTIFICATION_SERVICE);
    		tb=(Button)findViewById(R.id.threadSendMessage);
    		nbs=(Button)findViewById(R.id.withoutBindService);
    		bs=(Button)findViewById(R.id.withBindService);
    		end=(Button)findViewById(R.id.end);
    		intent=new Intent(MainActivity.this,LocalService.class);
    		intent2=new Intent(MainActivity.this,withoutBind.class);
    		bindService(intent2,connection,Context.BIND_AUTO_CREATE);
    	//开启新线程推送消息的按钮的监听
    	tb.setOnClickListener(new OnClickListener() {
    		@Override
    		public void onClick(View v) {
    			isinteerupt=!isinteerupt;
    			if(isinteerupt)
    				{
    				tb.setText("子线程推送消息");
    				handler.removeCallbacks(runnable);   //停止计时器
    				Log.i("提示:","中断线程");
    				}
    			else
    				{
    				tb.setText("暂停推送");
    				handler.post(runnable);//启动计时器,每两秒执行一次runnable.  
    			    Log.i("提示:","开始线程");
    			}
    		}
    	});
    		//开启非绑定类服务(黑科技,双进程互相启动)推送消息的按钮的监听
    		nbs.setOnClickListener(new OnClickListener() {
    			@Override
    			public void onClick(View v) {
    				Beginintentservice=!Beginintentservice;
    				if(Beginintentservice) {
    					nbs.setText("暂停推送");
    				    startService(intent);
    				    Log.i("LocalService","start");
    				}
    				else {
    					stopService(intent);
    					nbs.setText("开始推送");
    				}
    			}
    		});
    		//开启绑定使用messenger的服务推送消息的按钮的监听
    		bs.setOnClickListener(new OnClickListener() {
    			@Override
    			public void onClick(View v) {
    				Beginservice=!Beginservice;
    				if(Beginservice) {
    					bs.setText("暂停推送");
    					startService(intent2);
    					//如果连接服务成功,则绑定到服务
    					if(bound)
    					{
    					Log.i("BindService","Successful");}
    					//创建一个message消息并发送给服务端
    					 Message msgFromClient = Message.obtain(null, 0x111,0,0);
    	                  msgFromClient.replyTo = messenger1;
    	                    try {
    					messenger.send(msgFromClient);
    					}
    	                    catch(RemoteException e){
    	                    	Log.i("error",e.toString());
    	                    }
    				}
    				else {
    					bs.setText("开始推送");
    					stopService(intent2);
    				}
    			}
    		});
    		//结束按钮的监听
    		end.setOnClickListener(new OnClickListener() {
    			@Override
    			public void onClick(View v) {
    				finish();
    				Log.i("结束activity","finish");
    			}
    		});
    	}
    
    	/*
    	 * 重写服务连接以及断开连接方法
    	 */
    	private ServiceConnection connection=new ServiceConnection() {
    		@Override
    		public void onServiceConnected(ComponentName classname,IBinder service) {
    			messenger=new Messenger(service);
    			bound=true;
    		}
            public void onServiceDisconnected(ComponentName arg0) {
    			messenger=null;
            	bound=false;
    		}
    	};
    	/*
    	* 创建一个handler对象并重写runnable的run方法,实现,当线程启动时,自动启动消息推送
    	*/	
    	Handler handler=new Handler();  
    	Runnable runnable=new Runnable() {  
    	    @Override  
    	    public void run() {  
    	        // TODO Auto-generated method stub  
    	    	message="这个消息来自于子线程,APP结束后将会被结束";
    			//当线程不没有被中断,重复执行消息推送
    			title="线程的推送消息"+NOTIFYID_1;
    			Log.i("当前消息数:",String.valueOf(NOTIFYID_1));
    			statusBarSend();
    	        handler.postDelayed(runnable, 2000);      //自身调用自身,陷入2秒的定时循环
    	    }  
    	};  	
    /*
     * 实现状态栏推送消息的方法
     */
    	public void statusBarSend() {
    		@SuppressWarnings("deprecation")
    		Notification.Builder begin=new Notification.Builder(MainActivity.this);
    		begin.setSmallIcon(R.drawable.ic_launcher);
    		begin.setContentTitle(title);
    		begin.setContentText(message);
    		begin.setTicker(name);
    		begin.setWhen(System.currentTimeMillis()); //发送时间
    		Notification notification1 = begin.build();
    		notificationManager.notify(NOTIFYID_1, notification1);  // 通过通知管理器发送通知
    		NOTIFYID_1++;
    	}
    	/*
    	 * 创建messenger对象来处理由服务端发送的消息
    	 * @see android.app.Activity#onDestroy()
    	 */
    	private Messenger messenger1=new Messenger(new Handler() {
    		@SuppressLint("HandlerLeak")
    		@Override
    		public void handleMessage(Message msgFromwithoutBind) {
    			switch(msgFromwithoutBind.what) {
    			case isFromwithoutBind:
    				Log.i("MainActivity","Message receive");
    			}
    		}
    	});
    	@Override
    	protected void onDestroy() {
    		if(thread!=null) {
    			thread.interrupt();
    			thread=null;
    		}
    		super.onDestroy();
    	}
    	
    }

    withoutBind服务的CODE:
    /*
     * 该service是使用messenger类来实现服务以及与之绑定的组件之间的通信,服务端通过messenger来返回Ibinder对象
     * 客户端通过接收IBinder对象来获取服务。同时客户端可以发送message给服务端,服务端接收到对应的message
     * 之后,服务端将会在handleMessage里面处理这些消息
     */
    
    package com.example.servicetosendstatusbarmessage;
    import java.lang.ref.WeakReference;
    
    import android.app.NotificationManager;
    import android.app.Service;
    import android.content.Intent;
    import android.os.Handler;
    import android.os.IBinder;
    import android.os.Message;
    import android.os.Messenger;
    import android.os.RemoteException;
    import android.util.Log;
    
    public class withoutBind extends Service{
    	private static final int isFromMainActivity=0x111;
    	NotificationManager notificationManager;
    	//需要注意的是,内部类若是非静态,那么除非messageQueue消息全部处理完毕,否则将会阻止垃圾回收站回收外部类,
    	//当然这个问题只存在于主线程上,若是运行于子线程则没有影响,若要定义为非静态,必须在最后清空messageQueue
    	static class MyHandler extends Handler{
            WeakReference<withoutBind> mService;
            public MyHandler(withoutBind service) {
            	mService = new WeakReference<withoutBind>(service);
            }
            @Override
            public void handleMessage(Message msg) {
              // withoutBind mainService = mService.get(); //通过mService.get()获取withoutBind的引用(即上下文context)
            	Message msgToClient=Message.obtain(msg); //回复给客户端的消息
            	msgToClient.what=0x11;
               switch(msg.what) {
               case isFromMainActivity:
            	   //TODO
            	   Log.i("withoutBind", "Message receive");
            	   try {
            	   msg.replyTo.send(msgToClient);                   //回复客户端,注意的是,需要在客户端传递过来的message里面添加客户端messenger(该添加操作在客户端实现)
    
            	   Log.i("reply","successful");
            	   }catch(RemoteException e) {
            		   Log.i("error","reply error");
            	   }
            	   default:
            		  super.handleMessage(msg);
               }
            }
            }
    	Messenger messenger=new Messenger(new MyHandler(this));
    	@Override
    	public IBinder onBind(Intent intent) {
    		Log.i("onBinder","start");
    		return messenger.getBinder();
    	}
    	
    }
    

    LocalService的CODE:

    package com.example.servicetosendstatusbarmessage;
    
    import android.app.Notification;
    import android.app.NotificationManager;
    import android.app.Service;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Handler;
    import android.os.IBinder;
    import android.os.RemoteException;
    import android.util.Log;
    
    
    public class LocalService extends Service {
    
        private MyBinder binder;
        private MyConn conn;
        
        private String title,message,name="新消息";
    	int NOTIFYID_1=1;                          //消息推送码
    	NotificationManager notificationManager;
       
        @Override
        public IBinder onBind(Intent intent) {
            Log.i("LocalService", "onBind");
            return binder;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.i("LocalService", "onCreate");
            binder = new MyBinder();
            if (conn == null) {
                conn = new MyConn();
            }
            this.bindService(new Intent(this, RemoteService.class),
            		conn, Context.BIND_AUTO_CREATE);
            start();
        }
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
           // start();
        	Log.i("LocalService", "onStartCommand");
            this.bindService(new Intent(this, RemoteService.class),
            		conn, Context.BIND_AUTO_CREATE);
            return START_STICKY;
        }
    	//@Override
       // public void onStart(Intent intent, int startId) {
           // super.onStart(intent, startId);
          //  Log.i("LocalService", "onStart");
           // this.bindService(new Intent(this, RemoteService.class), conn, Context.BIND_IMPORTANT);
           // start();
       // }
    
        class MyBinder extends ServiceProcess.Stub {
    
            @Override
            public String getProcessName() throws RemoteException {
                return "LocalService";
            }
        }
    
        class MyConn implements ServiceConnection {
    
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                Log.i("LocalService", "远程服务启动");
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
                Log.i("LocalService", "远程服务断开");
                LocalService.this.startService(new Intent(LocalService.this,
                		RemoteService.class));
                LocalService.this.bindService(new Intent(LocalService.this, 
                		RemoteService.class), conn, Context.BIND_AUTO_CREATE);
            }
        }
        
        @Override
        public void onDestroy() {
          super.onDestroy();
          unbindService(conn);
        }
        
        
        
        
        
        public void start() {
    		handler.post(runnable);//启动计时器,每两秒执行一次runnable.  
    	}
    	public void end() {
    		handler.removeCallbacks(runnable);   //停止计时器
    	}
    	
    	
    	Handler handler=new Handler();  
    	Runnable runnable=new Runnable() {  
    	    @Override  
    	    public void run() {  
    	        // TODO Auto-generated method stub  
    	    	message="这个消息来自于未绑定服务,系统不会自动杀死该进程";
    			//当线程不没有被中断,重复执行消息推送
    			title="不绑定的服务推送消息"+NOTIFYID_1;
    			Log.i("当前消息数:",String.valueOf(NOTIFYID_1));
    			statusBarSend();
    	        handler.postDelayed(runnable, 2000);      //自身调用自身,陷入2秒的定时循环
    	    }  
    	}; 
    	
    	/*
    	 * 实现状态栏推送消息的方法
    	 */
    		public void statusBarSend() {
    			notificationManager=     //获取通知管理器
    					(NotificationManager)getSystemService(NOTIFICATION_SERVICE);
    			@SuppressWarnings("deprecation")
    			Notification.Builder begin=new Notification.Builder(LocalService.this);
    			begin.setSmallIcon(R.drawable.ic_launcher);
    			begin.setContentTitle(title);
    			begin.setContentText(message);
    			begin.setTicker(name);
    			begin.setWhen(System.currentTimeMillis()); //发送时间
    			Notification notification1 = begin.build();
    			notificationManager.notify(NOTIFYID_1, notification1);  // 通过通知管理器发送通知
    			NOTIFYID_1++;
    		}
    
        
    }

    RemoteService的代码:

    package com.example.servicetosendstatusbarmessage;
    
    import android.app.Service;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.IBinder;
    import android.os.RemoteException;
    import android.util.Log;
    
    public class RemoteService extends Service {
    
        private MyBinder binder;
        private MyConn conn;
    
        @Override
        public IBinder onBind(Intent intent) {
            Log.i("RemoteService", "onBind");
            return binder;
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.i("RemoteService", "onCreate");
            binder = new MyBinder();
            if (conn == null) {
                conn = new MyConn();
                
            }
            this.bindService(new Intent(this, LocalService.class), conn,
            		Context.BIND_AUTO_CREATE);
        }
    
    	@Override
        public int onStartCommand(Intent intent, int flags,int startId) {
           // super.onStartCommand(intent, startId);
            Log.i("RemoteService", "onStartCommand");
            this.bindService(new Intent(this, LocalService.class), conn,
            		Context.BIND_AUTO_CREATE);
       return START_STICKY;
    	}
    
        class MyBinder extends ServiceProcess.Stub {
    
            @Override       
            public String getProcessName() throws RemoteException {
                return "RemoteService";
            }
        }
    
    	class MyConn implements ServiceConnection {
    
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                Log.i("RemoteService", "本地服务启动");
            }
    
            @Override
            public void onServiceDisconnected(ComponentName componentName) {
                Log.i("RemoteService", "本地服务断开");
                RemoteService.this.startService(new Intent(RemoteService.this,
                		LocalService.class));
                RemoteService.this.bindService(new Intent(RemoteService.this,
                		LocalService.class), conn, Context.BIND_AUTO_CREATE);
    
            }
        }
    
        @Override
        public void onDestroy() {
          super.onDestroy();
          unbindService(conn);
        }
    
    }

    在SRC的资源包目录下创建ServiceProcess.aidl

    // ServiceProcess.aidl
    package com.example.servicetosendstatusbarmessage;
    
    // Declare any non-default types here with import statements
    
    interface ServiceProcess {
        /**
         * Demonstrates some basic types that you can use as parameters
         * and return values in AIDL.
         */
        String getProcessName();
    }

    编译后会在gen的包里自动生成JAVA文件:

    /*
     * This file is auto-generated.  DO NOT MODIFY.
     * Original file: G:\\安卓\\ServiceToSendStatusBarMessage\\src\\com\\example\\servicetosendstatusbarmessage\\ServiceProcess.aidl
     */
    package com.example.servicetosendstatusbarmessage;
    // Declare any non-default types here with import statements
    
    
    public interface ServiceProcess extends android.os.IInterface
    {
    /** Local-side IPC implementation stub class. */
    public static abstract class Stub extends android.os.Binder implements com.example.servicetosendstatusbarmessage.ServiceProcess
    {
    private static final java.lang.String DESCRIPTOR = "com.example.servicetosendstatusbarmessage.ServiceProcess";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
    this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.example.servicetosendstatusbarmessage.ServiceProcess interface,
     * generating a proxy if needed.
     */
    public static com.example.servicetosendstatusbarmessage.ServiceProcess asInterface(android.os.IBinder obj)
    {
    if ((obj==null)) {
    return null;
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (((iin!=null)&&(iin instanceof com.example.servicetosendstatusbarmessage.ServiceProcess))) {
    return ((com.example.servicetosendstatusbarmessage.ServiceProcess)iin);
    }
    return new com.example.servicetosendstatusbarmessage.ServiceProcess.Stub.Proxy(obj);
    }
    @Override public android.os.IBinder asBinder()
    {
    return this;
    }
    @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
    {
    java.lang.String descriptor = DESCRIPTOR;
    switch (code)
    {
    case INTERFACE_TRANSACTION:
    {
    reply.writeString(descriptor);
    return true;
    }
    case TRANSACTION_getProcessName:
    {
    data.enforceInterface(descriptor);
    java.lang.String _result = this.getProcessName();
    reply.writeNoException();
    reply.writeString(_result);
    return true;
    }
    default:
    {
    return super.onTransact(code, data, reply, flags);
    }
    }
    }
    private static class Proxy implements com.example.servicetosendstatusbarmessage.ServiceProcess
    {
    private android.os.IBinder mRemote;
    Proxy(android.os.IBinder remote)
    {
    mRemote = remote;
    }
    @Override public android.os.IBinder asBinder()
    {
    return mRemote;
    }
    public java.lang.String getInterfaceDescriptor()
    {
    return DESCRIPTOR;
    }
    @Override public java.lang.String getProcessName() throws android.os.RemoteException
    {
    android.os.Parcel _data = android.os.Parcel.obtain();
    android.os.Parcel _reply = android.os.Parcel.obtain();
    java.lang.String _result;
    try {
    _data.writeInterfaceToken(DESCRIPTOR);
    mRemote.transact(Stub.TRANSACTION_getProcessName, _data, _reply, 0);
    _reply.readException();
    _result = _reply.readString();
    }
    finally {
    _reply.recycle();
    _data.recycle();
    }
    return _result;
    }
    }
    static final int TRANSACTION_getProcessName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    }
    public java.lang.String getProcessName() throws android.os.RemoteException;
    }


    展开全文
  • 实 验 报 告 2013/2014 学年 第一学期 课程名称 软件技术系列课程 Android 基础 实验名称 Android 广播线程服务与多媒体开发 实验时间 2013 年 12 月 9 日 指导单位 计算机学院诚迈科技南京公司 指导教师 学生姓名 ...
  • 实 验 报 告 2013/2014 学年 第一学期 课程名称 软件技术系列课程Android 基础 实验名称 Android 广播线程服务与多媒体开发 实验时间 2013 年 12 月 9 日 指导单位 计算机学院诚迈科技南京公司 指导教师 学生姓名 ...
  •  安卓的UI线程是不安全的,要实现应用程序中的UI元素,必须在主线程中进行,否则异常。(即打开应用为主线程,而应用中的功能必须在子线程中进行)  利用异步消息处理机制进行UI操作。 即,将子线程程序不做逻辑...

           服务是基于应用程序的进程所开展而来,依赖改进程的应用程序。

           安卓的UI线程是不安全的,要实现应用程序中的UI元素,必须在主线程中进行,否则异常。(即打开应用为主线程,而应用中的功能必须在子线程中进行)

          利用异步消息处理机制进行UI操作。 即,将子线程程序不做逻辑动作,而将子线程发出message给Handler,Handler接收到后,在handlerMessage()中进行处理,而此时方法已在主线程中,故子线程发消息给主线程的接受者,再在主线程中进行处理逻辑动作。 

         安卓中的异步处理消息机制由4个部分组成:Message,Handler,MessageQueue,Looper。

         1.Message   在线程之间传递消息,本身可携带少量信息。

         2.Handler  用于发送和处理消息,发消息用的是Handler的sendMessage()方法, 接受到消息是在Handler的handler的handleMessage()方法中。

         3.MessageQueue 存放通过Handler发送过来的消息,类似于一个消息队列

         4.Looper 作为MessageQueue的管家,调用了Looper 的loop()方法后 实现一个循环,每回取以此队列中的消息,再和前面的过程一样,传递到Handler的handlerMessage()方法中。

        总结下来就是,首先在主线程中创建Handler对象,并且重写了handlerMesaage()方法。子线程要进行UI操作时,创建一个Message对象,并利用Handler将消息发出,发出的消息被添加到MessageQueue队列中,接着Looper从队列中取出消息,再分发回Handler的handlerMessage()方法中,由于此方法建立在主线程中,故。

     

     

    服务

    定义一个服务,重写Service中的方法

    onCreate()   在服务创建时调用         

    onStartCommand()  在每次服务启动时调用   

     onDestory() 在服务销毁时调用(回收不再使用的资源)

     

    活动与服务之间的通信   P356

    活动通知了服务,服务就直接进行下去了, 活动在指挥服务的进行。即只提供通知开始服务,但并不知道活动中服务进行的情况

    创建一个A类来继承Binder,并在A类内部提供方法, 然后再继承Service的服务中创建A的实例,在onBinder()方法中返回这个实例,如此这个服务就完成了。            当一个活动和服务绑定时,即可调用服务中的Binder提供的方法。                                                                                                                 

    展开全文
  • 1. asyncTask中有两个线程池; 2.AsyncTask是串行进行任务,如果要并行,就要用...4.stopSelf(int startId)会等待所有的消息处理完毕之后才终止服务; 5.Android中有4个线程池: 5.1)FixedThreadPool,

    1. asyncTask中有两个线程池;

    2.AsyncTask是串行进行任务,如果要并行,就要用executeonExecutor

    3.每次启动IntentService,她的onStartCommand方法就会调用一次;

    4.stopSelf(int startId)会等待所有的消息处理完毕之后才终止服务;

    5.Android中有4个线程池:

    5.1)FixedThreadPool,只有核心线程,而且数量固定,不会被系统回收;

    5.2)CachedThreadPool ,只有非核心线程,线程数量不确定,超时60s就会被回收,

    5.3)ScheduledThreadPool ,核心线程数量固定,而非核心线程的数量没有限制,非核心线程闲置时会被立即回收(用于执行定时任务,或固定周期的重复的任务)

    5.4)SingleThreadExecutor , 内部只有一个核心线程;

    展开全文
  • 如:文件的长度为6M,线程数为3,那么,每条线程下载的数据长度为2M,每条线程开始下载的位置如下图所示: (网上找的图) 例如10M大小,使用3个线程来下载, 线程下载的数据长度 (10%3 == 0 ? 10/3:10/3+1) ...

    实现原理
    (1)首先获得下载文件的长度,然后设置本地文件的长度。
    (2)根据文件长度和线程数计算每条线程下载的数据长度和下载位置。
    如:文件的长度为6M,线程数为3,那么,每条线程下载的数据长度为2M,每条线程开始下载的位置如下图所示:
    这里写图片描述
    (网上找的图)
    例如10M大小,使用3个线程来下载,
    线程下载的数据长度 (10%3 == 0 ? 10/3:10/3+1) ,第1,2个线程下载长度是4M,第三个线程下载长度为2M
    下载开始位置:线程id*每条线程下载的数据长度 = ?
    下载结束位置:(线程id+1)*每条线程下载的数据长度-1=?

    直接上代码:
    1.DownLoad.java

    
    import android.os.Environment;
    import android.os.Handler;
    import android.os.Message;
    import java.io.File;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.RandomAccessFile;
    import java.net.HttpURLConnection;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.concurrent.Executor;
    import java.util.concurrent.Executors;
    
    public class DownLoad {
    
        private Handler handler;
    
        public DownLoad(Handler handler) {
            this.handler = handler;
        }
    
        //创建是哪个线程池,用来下载数据
        private Executor threadPool = Executors.newFixedThreadPool(3);
    
        //给线程池创建一个Runnable对象
        static class DownLoadRunnable implements Runnable{
    
            private String url;
            private String fileName;
            private long start;//下载的启示位置
            private long end;//下载的结束位置
            private Handler handler;
    
            public DownLoadRunnable(String url, String fileName, long start, long end, Handler handler) {
                this.url = url;
                this.fileName = fileName;
                this.start = start;
                this.end = end;
                this.handler = handler;
            }
    
            @Override
            public void run() {
                try {
                    URL httpUrl = new URL(url);
                    HttpURLConnection conn = (HttpURLConnection) httpUrl.openConnection();
                    conn.setRequestMethod("GET");
                    conn.setReadTimeout(5000);
                    /*
                     1.Http协议字段 Range "bytes="+start+"-"+end
                     2.RandomAccessFile设置写入的位置
                     3.开启线程发送网路请求
                     */
                    conn.setRequestProperty("Range", "bytes=" + start + "-" + end);//获得请求数据的长度;
                    //通过RandomAccessFile(随机读取流)对本地文件进行写操作,rwd代表可读可写可执行
                    RandomAccessFile access = new RandomAccessFile(new File(fileName),"rwd");
                    access.seek(start);//从start开始写
                    InputStream in = conn.getInputStream();
                    byte[] b = new byte[1024*4];//创建一个缓冲区,4K
                    int len = 0;
                    while((len = in.read(b))!=-1){
                        access.write(b,0,len);//从0开始,读取len的一个长度
                    }
                    //读取完之后关闭这个流
                    if(access!=null){
                        access.close();
                    }
                    //读取玩之后关闭输入流
                    if(in!=null){
                        in.close();
                    }
                    //所有文件下载完成之后,给主线程发送一个消息
                    Message message = new Message();
                    message.what = 1;
                    handler.sendMessage(message);
    
                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 多线程文件下载
         */
        public void downLoadFile(String url){
            try {
                URL httpUrl = new URL(url);
                HttpURLConnection conn = (HttpURLConnection) httpUrl.openConnection();
                conn.setRequestMethod("GET");
                conn.setReadTimeout(5000);
                //拿到用来下载图片的长度
                int count = conn.getContentLength();
                //将长度分为三段
                int block = count/3;
    
                //指定一个文件的名字
                String fileName = getFileName(url);
                //拿到文件名后,需要指定一个文件的下载地址,下载到SD卡
                File parent = Environment.getExternalStorageDirectory();
                File fileDownLoad = new File(parent,fileName);
    
                //往线程池提交任务
                /**
                 * 假如有11个字节,则11/3 = 3
                 * 第一个线程 0-2
                 * 第二个线程 3-5
                 * 第三个线程 6-10  最后一个线程处理多出来的
                 */
                for (int i = 0; i<3;i++){
                    long start = i*block;
                    long end = (i+1)*block-1;
                    if(i==2){
                        end = count;
                    }
                    //fileDownLoad.getAbsolutePath()是获取绝对路径
                    DownLoadRunnable runnable = new DownLoadRunnable(url,
                            fileDownLoad.getAbsolutePath(),start,end,handler);
                    //通过线程池去提交任务
                    threadPool.execute(runnable);
                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //取出url后缀名的方法
        public String getFileName(String url){
            return url.substring(url.lastIndexOf("/")+1);
        }
    
    }
    

    2.MainActivity.java

    package com.ceshi.hwy.download;
    
    import android.app.Activity;
    import android.os.Handler;
    import android.os.Message;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    
    public class MainActivity extends Activity {
    
        private Button button;
        private TextView textView;
    
        private int count = 0;
    
        /**
         * 使用Handler更新UI界面信息
         */
        private Handler handler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                int result = msg.what;
                count+=result;
                if(count == 3){
                    textView.setText("download success!!!");
                }
            }
        };
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            button = (Button) findViewById(R.id.button);
            textView = (TextView) findViewById(R.id.textview);
            button.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    new Thread(){
                        @Override
                        public void run() {
                            DownLoad downLoad = new DownLoad(handler);
                            downLoad.downLoadFile("http://192.168.173.1:8080/web/hai.jpg");
                        }
                    }.start();
    
                }
            });
        }
    }
    

    3.布局文件就一个按钮和一个TextView,下面是结果图
    这里写图片描述
    这里写图片描述

    展开全文
  • } //广播接受者,接受来自ClockService(计时服务)的广播,ClockService每隔一秒钟发一次广播 private BroadcastReceiver clockReceiver=new BroadcastReceiver(){ @Override public void onReceive(Context ...
  • 1.1)线程基本用法 Class MyThread extends Thread{  Public void run(){} } new MyThread().start(); 使用继承耦合度比较高,更多选择使用实现Runnable接口的方式来定义一个线程 Class MyThread implements ...
  • 安卓系统蓝牙协议栈 bluedroid 使能流程分析本文承接上篇文章《安卓中蓝牙系统服务层的使能流程分析》,接续分析协议栈层相关的使能流程,所以蓝牙协议栈bluedroid的使能始于JNI层enableNative()中调用协议栈接口...
  • 使用POST方式提交数据时的中文乱码解决方法(重点) 解决办法:使用客户端和服务器两边的字符集编码保持一致。 UTF-8, 使用GET方式提交数据的中文乱码的解决方法 使用URLEncoder.encode(name,"UTF-8")进行url编码:...
  • 参考资料:郭霖第一行代码及网上公开资料这里只是简单的介绍一下java多线程的知识,然后主要讲解的是安卓如何在子线程中更新UI当我们需要执行一些耗时操作,比如说发起一条网络请求,考虑到网速等其他原因,服务器...
  • 屏幕休眠之后,即使后台有服务在运行,但是服务中的线程会自动停止,请问如何让线程一直运行不停止?
  • 一般情况下从TCP服务器读取数据是放在一个线程里读的,但是刷新界面又不得不放在线程外面,所以需要用消息传递把线程里从TCP里获得的数据传送出来,然后根据数据对页面进行相应的刷新。 二、业务逻辑: 这里包含2...
  • 安卓Android单任务多线程任意断点下载【源码】,包括了一个可复用的文件下载服务类用于获取实时更新每条线程已经下载的文件长度,可实现多任务下载  1.创建XML文件,将要生成的View配置好  2.获取系统服务...
  • // Provider的状态在可用、暂时不可用和无服务三个状态直接切换时触发此函数 @Override public void onStatusChanged(String provider, int status, Bundle extras) { } // Provider被enable时触发此函数,...
  • 安卓绑定服务

    2021-02-27 11:45:14
    1、服务 Android中的四大组件之一它能够长期在后台运行且不提供用户界面即使用户到另一应用程序,服务仍可以在后台运行 2、服务的特点 Service在后台运行,不用与用户进行交互 即使程序被切换到后台,或者用户打开...
  • 安卓学习笔记6——多线程下载器一、项目整体介绍1、项目逻辑流程2、项目目的:二、项目代码三、遇到的问题 一、项目整体介绍 使用HttpUrlConnection与服务器建立连接,获取文件长度,开多个线程下载资源,使用...
  • 这个任务栈与线程和进程没有任何关系 。 这个任务栈内部实现是一个链表。它是一个后进先出的数据结构。 它其实就是用于记录activity的状态的东西。 Intent的启动模式: SingleTop如果任务栈的栈顶元素是要被激活的...
  • 以后做图片下载请求,或者请求服务器记得新开线程
  • 大概搞了三天吧,我一直在修改ip地址,由于自己网络知识不扎实,再加上刚接触安卓,具体有很多东西也不熟,做了很多无用功。 好了,废话少说,进入正题。 本次使用的服务器是apache ftp server1.0.6.遇到的问题如下...
  • 常识:从百度百科上面我们知道,SharedPreferences是不支持多线程的,但是这次我使用sp成功的实现了多线程断点下载。 服务器: 使用的是tomcat服务器,在C:\apache-tomcat-7.0.59\webapps\ROOT目录下存放pp.zip文件...
  • 安卓学习之后台服务

    2020-04-03 16:49:46
    安卓线程 先从线程开始学起 线程的基本用法 用Thread 跟java的用法一样,比如说,定义一个线程只需要新建一个类继承自Thread,然后重写父类的run()方法,并在里面编写耗时逻辑即可。 class MyThread extends ...
  • 《方式一:多线程下载之常规实现》 原理如图: 1.创建urlURL url = new URL(getUrl());//下载来自tomcat下的webapps/ROOT/resource.rar文件,10.0.2.2是安卓映射的服务器的地址,此时不再是localhost或者是本机...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 294
精华内容 117
关键字:

安卓服务线程