Android之网络摄像头-低调大师

Android之网络摄像头

2017-04-09 544

实现的功能就是两个手机在一个局域网内可以互相观看对方的摄像头图像,当然如果都是连接公网那么就能远程互看了,,,,和视频聊天差不多,,不过没有声音,,,,,,,,

源码是在网上找的(具体地址忘了,如有侵犯请告知),亲测能用,,其实一开始想直接用到自己现在做的东西上 ,不过直接加到自己现在的软件上,调试了一下发现,,我想多了,老天总是不让自己那么轻易的.......................

因为自己手头上只有一个手机,所以就自己发给自己了,本想像写其它文章似得详细叙述一番,看了一下表,,感觉还是算了吧,,昨天把程序加到自己的软件上然后修改,测试一直熬到了1点,然后下午上班的时候头疼,困,然后就睡了1个小时.............年轻人不要老熬夜,,对身体不好,

上面的是自己的摄像头预览的,

下面的是通过TCP传输过来的

源码如下

package com.example.realtimevideo;


import java.io.ByteArrayOutputStream;

import com.example.threadConnect.ClientThread;
import com.example.threadConnect.RevImageThread;


import android.graphics.Bitmap;
import android.graphics.ImageFormat;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.hardware.Camera.PreviewCallback;
import android.hardware.Camera.Size;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.app.Activity;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Menu;
import android.view.SurfaceHolder;
import android.view.Window;
import android.view.WindowManager;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;
import android.widget.ImageView;
import android.widget.RelativeLayout;

public class MainVideoActivity extends Activity{
    RevImageThread revImageThread;
    public static ImageView image;
    private static Bitmap bitmap;
    private static final int COMPLETED = 0x222;
    
    
    MyHandler handler;
    ClientThread clientThread;
    ByteArrayOutputStream outstream;
    
    SurfaceView surfaceView;
    SurfaceHolder  sfh;
    Camera camera;
    boolean isPreview = false;        //是否在浏览中
    static int screenWidth=300;
    static int screenHeight=300;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 设置全屏
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_main_video);
        surfaceView = (SurfaceView)findViewById(R.id.surfaceView);
        image=(ImageView)findViewById(R.id.imageView1);
        
        handler = new MyHandler();
        clientThread = new ClientThread();
        new Thread(clientThread).start();
        
        revImageThread = new RevImageThread(handler);
        new Thread(revImageThread).start();
        
        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        screenWidth = dm.widthPixels;// 获取屏幕分辨率宽度
        screenHeight = dm.heightPixels;
        
        
        image.setLayoutParams(new RelativeLayout.LayoutParams(screenWidth,screenHeight));  
        //image.setMaxHeight(screenHeight);
        //image.setMaxWidth(screenWidth);
        
        image.setMaxHeight(screenHeight/2);
        sfh = surfaceView.getHolder(); 
        sfh.setFixedSize(screenWidth, screenHeight/2);
         
        sfh.addCallback(new Callback(){

            @Override
            public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2,
                    int arg3) {
                // TODO Auto-generated method stub
                
            }

            @Override
            public void surfaceCreated(SurfaceHolder arg0) {
                // TODO Auto-generated method stub
                initCamera();
            }

            @Override
            public void surfaceDestroyed(SurfaceHolder arg0) {
                if (camera != null) {
                    if (isPreview)
                    
                    camera.stopPreview();
                    camera.release();
                    camera = null;
                }
                
            }
            
        });
        
    }
    

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main_video, menu);
        return true;
    }
    
    @SuppressWarnings("deprecation")
    private void initCamera() {
        if (!isPreview) {
            int k = 0;
            if((k=FindBackCamera())!=-1){
                camera = Camera.open(k);
            }else{
                camera = Camera.open();
            }
            ClientThread.size = camera.getParameters().getPreviewSize();   
        }
        if (camera != null && !isPreview) {
            try{
                camera.setPreviewDisplay(sfh);                 // 通过SurfaceView显示取景画面    
                Camera.Parameters parameters = camera.getParameters();                
                parameters.setPreviewSize(screenWidth, screenHeight/4*3);   
                 /* 每秒从摄像头捕获5帧画面， */  
                parameters.setPreviewFrameRate(5); 
                parameters.setPictureFormat(ImageFormat.NV21);           // 设置图片格式                
                parameters.setPictureSize(screenWidth, screenHeight/4*3);    // 设置照片的大小
                camera.setDisplayOrientation(90);
                camera.setPreviewCallback(new PreviewCallback(){
                    @Override
                    public void onPreviewFrame(byte[] data, Camera c) {
                        // TODO Auto-generated method stub
                         Size size = camera.getParameters().getPreviewSize();          
                            try{ 
                                //调用image.compressToJpeg（）将YUV格式图像数据data转为jpg格式
                                YuvImage image = new YuvImage(data, ImageFormat.NV21, size.width, size.height, null);  
                                if(image!=null){
                                    Message msg = clientThread.revHandler.obtainMessage();
                                    msg.what=0x111;
                                    msg.obj=image;
                                    clientThread.revHandler.sendMessage(msg);
                                }
                            }catch(Exception ex){  
                                    Log.e("Sys","Error:"+ex.getMessage());  
                            }
                    }
                    
                });
                camera.startPreview();                                   // 开始预览                
                camera.autoFocus(null);                                  // 自动对焦
            } catch (Exception e) {
                e.printStackTrace();
            }
            isPreview = true;
        }
    }
    
    static class MyHandler extends Handler{
        @Override
        public void handleMessage(Message msg){
             if (msg.what == COMPLETED) {         
                 bitmap = (Bitmap)msg.obj;
                 
                 //image.setPivotX(image.getWidth()/2);
                  //image.setPivotX(image.getHeight()/2);
                  
                  
                 //image.setImageBitmap(bitmap);
                 image.setLayoutParams(new RelativeLayout.LayoutParams(screenWidth,screenHeight)); 
                 image.setImageBitmap(bitmap);
                 image.setRotation(90);
                 super.handleMessage(msg);
             }  
        }
    }
    
    //调用前置摄像头
    private int FindFrontCamera(){  
         int cameraCount = 0;  
         Camera.CameraInfo cameraInfo = new Camera.CameraInfo();  
         cameraCount = Camera.getNumberOfCameras(); // get cameras number   
        
         for ( int camIdx = 0; camIdx < cameraCount;camIdx++ ) {  
             Camera.getCameraInfo( camIdx, cameraInfo ); // get camerainfo   
             if ( cameraInfo.facing ==Camera.CameraInfo.CAMERA_FACING_FRONT ) {   
                 // 代表摄像头的方位，目前有定义值两个分别为CAMERA_FACING_FRONT前置和CAMERA_FACING_BACK后置   
                 return camIdx;  
              }  
         }  
         return -1;  
    } 
    
    //调用后置摄像头
    private int FindBackCamera(){  
        int cameraCount = 0;  
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();  
        cameraCount = Camera.getNumberOfCameras(); // get cameras number   
        
        for ( int camIdx = 0; camIdx < cameraCount;camIdx++ ) {  
           Camera.getCameraInfo( camIdx, cameraInfo ); // get camerainfo   
           if ( cameraInfo.facing ==Camera.CameraInfo.CAMERA_FACING_BACK ) {   
               // 代表摄像头的方位，目前有定义值两个分别为CAMERA_FACING_FRONT前置和CAMERA_FACING_BACK后置   
               return camIdx;  
           }  
        }  
        return -1;  
    }  
}

package com.example.threadConnect;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;

import android.graphics.Rect;
import android.graphics.YuvImage;
import android.hardware.Camera.Size;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class ClientThread implements Runnable {
    private static Socket socket ;
    private static ByteArrayOutputStream outputstream;
    private static byte byteBuffer[] = new byte[1024];
    public static Size size;
    
    //接受UI线程消息
    public MyHandler revHandler;
    
    BufferedReader br= null;
    static OutputStream os = null;
    

    @Override
    public void run() {
        Looper.prepare();
        //接受UI发来的信息
        revHandler = new MyHandler();
        Looper.loop();
    }
    
    public static class MyHandler extends Handler{
        @Override
        public void handleMessage(Message msg){
            if(msg.what==0x111){
                try {
                    socket = new Socket("192.168.3.10",8081);
                    os = socket.getOutputStream(); 
                    YuvImage image = (YuvImage) msg.obj;
                    if(socket.isOutputShutdown()){
                        Log.e("output is down","ljq");
                    }else{
                        os = socket.getOutputStream();  
                        outputstream = new ByteArrayOutputStream();
                        image.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, outputstream);
                        ByteArrayInputStream inputstream = new ByteArrayInputStream(outputstream.toByteArray());
                        int amount;
                        while ((amount = inputstream.read(byteBuffer)) != -1) {
                            os.write(byteBuffer, 0, amount);
                        }
                        os.write("\n".getBytes());
                        outputstream.flush();
                        outputstream.close();
                        os.flush();
                        os.close();
                        socket.close();
                    }
                } catch (UnsupportedEncodingException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.example.threadConnect;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Handler;
import android.os.Message;

public class RevImageThread implements Runnable {

    public Socket s;
    public ServerSocket ss;
    
    //向UI线程发送消息
    private Handler handler;
    
    private Bitmap bitmap;
    private static final int COMPLETED = 0x222;
    
    public RevImageThread(Handler handler){
        this.handler = handler;
    }
    
    public void run()
    {    
        byte [] buffer = new byte[1024];
        int len = 0;

    
        try {
            ss = new ServerSocket(8080);
        } catch (IOException e2) {
            // TODO Auto-generated catch block
            e2.printStackTrace();
        }

        InputStream ins = null;
        while(true){
            
            try {
                s = ss.accept();
                ins = s.getInputStream();
                
                ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
                while( (len=ins.read(buffer)) != -1){      
                    outStream.write(buffer, 0, len); 
                }
                ins.close();
                
                byte data[] = outStream.toByteArray(); 
                bitmap = BitmapFactory.decodeByteArray(data, 0, data.length); 
                
                Message msg =handler.obtainMessage();
                msg.what = COMPLETED;
                msg.obj = bitmap;
                handler.sendMessage(msg);
                
                outStream.flush();
                outStream.close();
                if(!s.isClosed()){
                    s.close();
                }
                
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            //Bitmap bitmap = BitmapFactory.decodeStream(ins);
            
        }
    }

}

布局

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    android:orientation="vertical"
    tools:context=".MainVideoActivity" >

    <SurfaceView 
        android:id="@+id/surfaceView"
        android:layout_width="fill_parent" 
        android:layout_height="fill_parent"
        android:scaleType="fitCenter"
        />
     <ImageView 
        android:id="@+id/imageView1"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
       
        android:src="@drawable/ic_launcher"/>
</RelativeLayout>

权限

对了关于如何使用

这个程序把发送图像和接收图像做在了一块了

其实只有知道TCP通信应该就会用,,不对源程序没提供地址输入框,,,,,,,后期自己加上了,不过现在感觉需要修改,因为源程序是不停的申请不停的释放,,,,,,

未完,,待续,,改好了就把自己完善的代码奉上, 加详细解释,一步一步的写出来..................

微信关注我们

原文链接：https://yq.aliyun.com/articles/580176

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

滥用Accessibility service自动安装应用

一、恶意应用简介：近年许多的android市场实现免root安装应用，也就是下载完成立即自动安装，而黑产界也同样利用该技术在进行恶意推广，静默安装。最近拦截到大量恶意应用利用系统AccessibilityService静默安装应用。一旦恶意的Accessibility服务被激活，恶意应用将弹出广告，即使用户关闭弹出的广告该应用程序也会在后台下载，随后自动安装推广的恶意应用。二、AccessibilityService介绍： AccessibilityService作用： Android Accessibility用于那些由于视力、听力或其它身体原因导致不能方便使用Android智能手机的用户，Android提供了Accessibility功能和服务帮助这些用户更加简单地操作设备。开发者可以搭建自己的Accessibility服务，这可以加强应用的可用性。开启AccessibilityService后应用通过它能实时地获取当前操作应用的窗口元素信息，并能够双向交互，既能获取用户的输入，也能对窗口元素进行操作，比如点击按钮。 AccessibilityService的使用场景： And...

2017-04-10

544

前言：在13年11月中旬时，因为基础组件组人手紧张，Leo安排我和春哥去广州轮岗支援。刚到广州的时候，Ray让我和春哥对Line和WhatsApp的心跳机制进行分析。我和春哥抓包测试了差不多两个多礼拜，在我们基本上摸清了Line和WhatsApp的心跳机制后，Ray才告诉我们真正的任务——对微信的固定心跳进行优化，并告诉我们这不是一件容易的事情。于是我和春哥开始构思第一个方案，我们开始想用统计的方法来解决问题，当我们拿着第一个方案和Ray讨论时，发现不能优雅应对Ray的所有提问：1、测试环境的准确性，失败到底是因为网络的特性导致还是因为用户当前的环境变化导致的暂时失败。2、临界值界定，如果方案选中的心跳值是临界值，我们该怎么办。Ray和组件组同事在网络方面有极其丰富的经验，虽然他没有给我们指出明确的方向，但提出的问题帮助我们更快的补齐需要面对的核心问题。这两个问题让我和春哥意识到如果能很好的解决，就可以给出一个比较好的心跳方案。第一个问题我和春哥开始就意识到，第二个问题我们确实在一开始时疏忽了。但直接解决这两个问题确实不容易，这着实让我和春哥迷茫了几天，有两三天在纺园我都没怎么睡着，因...

2017-04-11

541

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。