android设备局域网中快速搜索之cling方式

最新推荐文章于 2025-12-10 01:27:51 发布
原创 最新推荐文章于 2025-12-10 01:27:51 发布 · 3.1k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#android #局域网 #物联网 #快速搜索设备
本文介绍了在物联网环境下，如何利用cling基于UPnP协议在局域网中快速搜索设备。阐述了服务端如何注册设备，并展示了客户端扫描和添加设备的代码，强调了搜索速度如同Windows局域网刷新成员一样迅速。

语音在线听书demo：http://blog.csdn.net/ls0609/article/details/71519203

语音记账demo：http://blog.csdn.net/ls0609/article/details/72765789

基于JavaScript用olamisdk实现web端语音识别语义理解（speex压缩）

http://blog.csdn.net/ls0609/article/details/73920229

在物联网时代，有时需要在局域网中快速搜索设备，本片讲述cling搜索的一个例子。

UPnP全名是Universal Plug and Play，主要是微软在推行的一个标准。简单的来说，UPnP 最大的愿景就是希望任何设备只要一接上网络，所有在网络上的设备马上就能知道有新设备加入，这些设备彼此之间能互相沟通，更能直接使用或控制它，一切都不需要设定，完全的Plug and Play。

cling就是采用了这个协议来进行服务端的注册和客户端的扫描发现。

服务端注册后，客户端扫描大概时间在2-5秒，就像windows平台局域网刷新群组内成员一样迅速，如下图扫描结果：

这里写图片描述

首先看服务端如何注册

public class MainActivity extends Activity implements PropertyChangeListener {

    // DOC:CLASS
    private static final Logger log = Logger.getLogger(MainActivity.class.getName());

    // DOC:SERVICE_BINDING
    private AndroidUpnpService upnpService;

    private UDN udn = new UDN(UUID.randomUUID()); // TODO: Not stable!

    private ServiceConnection serviceConnection = new ServiceConnection() {

        public void onServiceConnected(ComponentName className, IBinder service) {
            upnpService = (AndroidUpnpService) service;

            LocalService<SwitchPower> switchPowerService = getSwitchPowerService();

            // Register the device when this activity binds to the service for the first time
            if (switchPowerService == null) {
                try {
                    LocalDevice binaryLightDevice = createDevice();

                    Toast.makeText(MainActivity.this, R.string.registeringDevice, 
                    Toast.LENGTH_SHORT).show();
                    upnpService.getRegistry().addDevice(binaryLightDevice);

                    switchPowerService = getSwitchPowerService();

                } catch (Exception ex) {
                    log.log(Level.SEVERE, "Creating BinaryLight device failed", ex);
                    Toast.makeText(MainActivity.this, R.string.createDeviceFailed, 
                    Toast.LENGTH_SHORT).show();
                    return;
                }
            }

            // Obtain the state of the power switch and update the UI
            setLightbulb(switchPowerService.getManager().getImplementation().getStatus());

            // Start monitoring the power switch
            switchPowerService.getManager().getImplementation().getPropertyChangeSupport()
                    .addPropertyChangeListener(MainActivity.this);

        }

        public void onServiceDisconnected(ComponentName className) {
            upnpService = null;
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // DOC:LOGGING
        // Fix the logging integration between java.util.logging and Android internal logging
        // org.seamless.util.logging.LoggingUtil.resetRootHandler(
        //    new FixedAndroidLogHandler()
        // );
        // Logger.getLogger("org.fourthline.cling").setLevel(Level.FINEST);
        // DOC:LOGGING

        setContentView(R.layout.light);

        getApplicationContext().bindService(
                new Intent(this, AndroidUpnpServiceImpl.class),
                serviceConnection,
                Context.BIND_AUTO_CREATE
        );
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        // Stop monitoring the power switch
        LocalService<SwitchPower> switchPowerService = getSwitchPowerService();
        if (switchPowerService != null)
            switchPowerService.getManager().getImplementation().getPropertyChangeSupport()
                    .removePropertyChangeListener(this);

        getApplicationContext().unbindService(serviceConnection);
    }

    protected LocalService<SwitchPower> getSwitchPowerService() {
        if (upnpService == null)
            return null;

        LocalDevice binaryLightDevice;
        if ((binaryLightDevice = upnpService.getRegistry().getLocalDevice(udn, true)) == null)
            return null;

        return (LocalService<SwitchPower>)
                binaryLightDevice.findService(new UDAServiceType("SwitchPower", 1));
    }
    // DOC:SERVICE_BINDING

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        menu.add(0, 0, 0, R.string.switchRouter).setIcon(android.R.drawable.ic_menu_revert);
        menu.add(0, 1, 0, R.string.toggleDebugLogging).setIcon(android.R.drawable.ic_menu_info_details);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case 0:
                if (upnpService != null) {
                    Router router = upnpService.get().getRouter();
                    try {
                        if (router.isEnabled()) {
                            Toast.makeText(this, R.string.disablingRouter, 
                            Toast.LENGTH_SHORT).show();
                            router.disable();
                        } else {
                            Toast.makeText(this, R.string.enablingRouter, 
                            Toast.LENGTH_SHORT).show();
                            router.enable();
                        }
                    } catch (RouterException ex) {
                        Toast.makeText(this, getText(R.string.errorSwitchingRouter) + 
                        ex.toString(), Toast.LENGTH_LONG).show();
                        ex.printStackTrace(System.err);
                    }
                }
                break;
            case 1:
                Logger logger = Logger.getLogger("org.fourthline.cling");
                if (logger.getLevel() != null && !logger.getLevel().equals(Level.INFO)) {
                    Toast.makeText(this, R.string.disablingDebugLogging, 
                    Toast.LENGTH_SHORT).show();
                    logger.setLevel(Level.INFO);
                } else {
                    Toast.makeText(this, R.string.enablingDebugLogging, 
                    Toast.LENGTH_SHORT).show();
                    logger.setLevel(Level.FINEST);
                }
                break;
        }
        return false;
    }

    // DOC:PROPERTY_CHANGE
    public void propertyChange(PropertyChangeEvent event) {
        // This is regular JavaBean eventing, not UPnP eventing!
        if (event.getPropertyName().equals("status")) {
            log.info("Turning light: " + event.getNewValue());
            setLightbulb((Boolean) event.getNewValue());
        }
    }

    protected void setLightbulb(final boolean on) {
        runOnUiThread(new Runnable() {
            public void run() {
                ImageView imageView = (ImageView) findViewById(R.id.light_imageview);
                imageView.setImageResource(on ? R.drawable.light_on : 
                R.drawable.light_off);
                // You can NOT externalize this color into /res/values/colors.xml. 
                //Go on, try it!
                imageView.setBackgroundColor(on ? Color.parseColor("#9EC942") : 
                Color.WHITE);
            }
        });
    }
    // DOC:PROPERTY_CHANGE

    // DOC:CREATE_DEVICE
    protected LocalDevice createDevice()
            throws ValidationException, LocalServiceBindingException {

        DeviceType type =
                new UDADeviceType("BinaryLight", 1);

        DeviceDetails details =
                new DeviceDetails(
                        "MusicBox",//"Friendly Binary Light",
                        new ManufacturerDetails("ACME"),
                        new ModelDetails("Music_box_11000", "10.3.172.27", "v1")//new ModelDetails("AndroidLight", "A light with on/off switch.", "v1")
                );

        LocalService service = new AnnotationLocalServiceBinder().read(SwitchPower.class);

        service.setManager(new DefaultServiceManager<SwitchPower>(service, SwitchPower.class));

        return new LocalDevice(
                new DeviceIdentity(udn),
                type,
                details,
                createDefaultDeviceIcon(),
                service
        );
    }

服务端注册了一个ServiceConnection，createDevice()函数中的DeviceDetails中加入了设备的描述
upnpService.getRegistry().addDevice(binaryLightDevice);注册了这个设备到服务端，只有注册了才能搜索到。

再来看看扫描的客户端代码：

public class MainActivity extends ListActivity {

    // DOC:CLASS
    // DOC:SERVICE_BINDING
    private ArrayAdapter<DeviceDisplay> listAdapter;

    private BrowseRegistryListener registryListener = new BrowseRegistryListener();

    private AndroidUpnpService upnpService;

    private ServiceConnection serviceConnection = new ServiceConnection() {

        public void onServiceConnected(ComponentName className, IBinder service) {
            upnpService = (AndroidUpnpService) service;

            // Clear the list
            listAdapter.clear();

            // Get ready for future device advertisements
            upnpService.getRegistry().addListener(registryListener);

            // Now add all devices to the list we already know about
            for (Device device : upnpService.getRegistry().getDevices()) {
                registryListener.deviceAdded(device);
            }

            // Search asynchronously for all devices, they will respond soon
            upnpService.getControlPoint().search();
        }

        public void onServiceDisconnected(ComponentName className) {
            upnpService = null;
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Fix the logging integration between java.util.logging and Android internal logging
        org.seamless.util.logging.LoggingUtil.resetRootHandler(
            new FixedAndroidLogHandler()
        );
        // Now you can enable logging as needed for various categories of Cling:
        // Logger.getLogger("org.fourthline.cling").setLevel(Level.FINEST);

        listAdapter = new ArrayAdapter<DeviceDisplay>(this, android.R.layout.simple_list_item_1);
        setListAdapter(listAdapter);

        // This will start the UPnP service if it wasn't already started
        getApplicationContext().bindService(
            new Intent(this, AndroidUpnpServiceImpl.class),
            serviceConnection,
            Context.BIND_AUTO_CREATE
        );
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (upnpService != null) {
            upnpService.getRegistry().removeListener(registryListener);
        }
        // This will stop the UPnP service if nobody else is bound to it
        getApplicationContext().unbindService(serviceConnection);
    }
    // DOC:SERVICE_BINDING

    // DOC:MENU
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        menu.add(0, 0, 0, R.string.searchLAN).setIcon(android.R.drawable.ic_menu_search);
        // DOC:OPTIONAL
        menu.add(0, 1, 0, R.string.switchRouter).setIcon(android.R.drawable.ic_menu_revert);
        menu.add(0, 2, 0, R.string.toggleDebugLogging).setIcon(android.R.drawable.ic_menu_info_details);
        // DOC:OPTIONAL
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case 0:
                if (upnpService == null)
                    break;
                Toast.makeText(this, R.string.searchingLAN, Toast.LENGTH_SHORT).show();
                upnpService.getRegistry().removeAllRemoteDevices();
                upnpService.getControlPoint().search();
                break;
            // DOC:OPTIONAL
            case 1:
                if (upnpService != null) {
                    Router router = upnpService.get().getRouter();
                    try {
                        if (router.isEnabled()) {
                            Toast.makeText(this, R.string.disablingRouter, 
                            Toast.LENGTH_SHORT).show();
                            router.disable();
                        } else {
                            Toast.makeText(this, R.string.enablingRouter, 
                            Toast.LENGTH_SHORT).show();
                            router.enable();
                        }
                    } catch (RouterException ex) {
                        Toast.makeText(this, getText(R.string.errorSwitchingRouter) +
                         ex.toString(), Toast.LENGTH_LONG).show();
                        ex.printStackTrace(System.err);
                    }
                }
                break;
            case 2:
                Logger logger = Logger.getLogger("org.fourthline.cling");
                if (logger.getLevel() != null && !logger.getLevel().equals(Level.INFO)) {
                    Toast.makeText(this, R.string.disablingDebugLogging, 
                    Toast.LENGTH_SHORT).show();
                    logger.setLevel(Level.INFO);
                } else {
                    Toast.makeText(this, R.string.enablingDebugLogging, 
                    Toast.LENGTH_SHORT).show();
                    logger.setLevel(Level.FINEST);
                }
                break;
            // DOC:OPTIONAL
        }
        return false;
    }
    // DOC:MENU

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        AlertDialog dialog = new AlertDialog.Builder(this).create();
        dialog.setTitle(R.string.deviceDetails);
        DeviceDisplay deviceDisplay = (DeviceDisplay)l.getItemAtPosition(position);
        dialog.setMessage(deviceDisplay.getDetailsMessage());
        dialog.setButton(
            getString(R.string.OK),
            new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int which) {
                }
            }
        );
        dialog.show();
        TextView textView = (TextView) dialog.findViewById(android.R.id.message);
        textView.setTextSize(12);
        super.onListItemClick(l, v, position, id);
    }

    protected class BrowseRegistryListener extends DefaultRegistryListener {

        /* Discovery performance optimization for very slow Android devices! */
        @Override
        public void remoteDeviceDiscoveryStarted(Registry registry, 
                                                            RemoteDevice device)  
        {
            deviceAdded(device);
        }

        @Override
        public void remoteDeviceDiscoveryFailed(Registry registry, 
                                 final RemoteDevice device, final Exception ex) 
        {
            runOnUiThread(new Runnable() {
                public void run() {
                    Toast.makeText(
                        MainActivity.this,
                        "Discovery failed of '" + device.getDisplayString() + "': "
                            + (ex != null ? ex.toString() : "Couldn't retrieve 
                            + device/service descriptors"),
                        Toast.LENGTH_LONG
                    ).show();
                }
            });
            deviceRemoved(device);
        }
        /* End of optimization, you can remove the whole block 
        if your Android handset is fast (>= 600 Mhz) */

        @Override
        public void remoteDeviceAdded(Registry registry, RemoteDevice device) {
            deviceAdded(device);
        }

        @Override
        public void remoteDeviceRemoved(Registry registry, RemoteDevice device) {
            deviceRemoved(device);
        }

        @Override
        public void localDeviceAdded(Registry registry, LocalDevice device) {
            deviceAdded(device);
        }

        @Override
        public void localDeviceRemoved(Registry registry, LocalDevice device) {
            deviceRemoved(device);
        }

        public void deviceAdded(final Device device) {
            runOnUiThread(new Runnable() {
                public void run() {
                    DeviceDisplay d = new DeviceDisplay(device);
                    int position = listAdapter.getPosition(d);
                    if (position >= 0) {
                        // Device already in the list, re-set new value at same position
                        listAdapter.remove(d);
                        listAdapter.insert(d, position);
                    } else {
                        listAdapter.add(d);
                    }
                }
            });
        }

        public void deviceRemoved(final Device device) {
            runOnUiThread(new Runnable() {
                public void run() {
                    listAdapter.remove(new DeviceDisplay(device));
                }
            });
        }
    }

    protected class DeviceDisplay {

        Device device;

        public DeviceDisplay(Device device) {
            this.device = device;
        }

        public Device getDevice() {
            return device;
        }

        // DOC:DETAILS
        public String getDetailsMessage() {
            StringBuilder sb = new StringBuilder();
            if (getDevice().isFullyHydrated()) {
                sb.append(getDevice().getDisplayString());
                sb.append("\n\n");
                for (Service service : getDevice().getServices()) {
                    sb.append(service.getServiceType()).append("\n");
                }
            } else {
                sb.append(getString(R.string.deviceDetailsNotYetAvailable));
            }
            return sb.toString();
        }
        // DOC:DETAILS

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            DeviceDisplay that = (DeviceDisplay) o;
            return device.equals(that.device);
        }

        @Override
        public int hashCode() {
            return device.hashCode();
        }

        @Override
        public String toString() {
             String name = getDevice().getDetails().getFriendlyName() +" " 
             +getDevice().getDetails().getModelDetails().getModelName()+
                     getDevice().getDetails().getModelDetails().getModelDescription();
            return name;//device.isFullyHydrated() ? name : name + " *";
        }
    }
}

当ServiceConnection，onServiceConnected后，执行for循环添加设备
for (Device device : upnpService.getRegistry().getDevices()) {
registryListener.deviceAdded(device);
}
通过关联listview进行显示，

在下面函数中，可以看到搜索到设备的具体信息

public String toString() {
        String name = getDevice().getDetails().getFriendlyName() +" " 
          +getDevice().getDetails().getModelDetails().getModelName()+
                 getDevice().getDetails().getModelDetails().getModelDescription();
         return name;//device.isFullyHydrated() ? name : name + " *";
 }

代码下载地址

语音在线听书demo：http://blog.csdn.net/ls0609/article/details/71519203

语音记账demo：http://blog.csdn.net/ls0609/article/details/72765789

基于javascript用olamisdk实现web端语音识别语义理解（speex压缩）

http://blog.csdn.net/ls0609/article/details/73920229

Android系统下同Wi-Fi环境下投屏（源码+项目说明）.zip
02-21
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 3、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。 Android系统下同Wi-Fi环境下投屏（源码+项目说明）.zip
talentmov-master_talentmov-master_Welcome!_pandaliveapp_androidp
10-02
panda live app source
Cling2.0库基于DLNA实现android电视接收端
qq_36715345的博客
01-17 2769
当新的端点设备加入时,可主动通过SEARCH来查询已经注册的设备和对应的服务列表,选中设备后就可以获取到投屏设备的路径,uid于对应注册的服务。1.寻址阶段是 UPnP 工作流程中的基础，在 IPv4 的环境中，每台设备或每个控制点在同一网关下分配独立的IP地址。2.发现阶段,当开放了 UPnP 服务的设备加入网络后，该设备将以组播的方式，向网络中的控制点通知自己以及服务的存在。由此控制点实时获取投屏设备的状态,控制播放设备的声音,播放内容,进度条等等。
Android代码-Android-Cling
08-06
Android-Cling Example of use is available in Solid Launcher What is Cling library Cling is a library that allows you to create overlays that will allow the user to be informed of how your application works. There is already a bunch of libraries to do that, but I wanted a simple and light library that do this quickly, simply and fastly. And also without creating a Bitmap of the size of the screen ! You can display one unique overlay or sequence of overlays. Overlays are represented by Cling
simpledlna:基于cling实现的Android投屏方案
05-10
simpledlna 基于cling实现的Android投屏方案 源码解析参考
Android投屏方案（基于cling）
热门推荐
Rookie的专栏
07-22 2万+
一 、前言 最近做了一个浏览器&视频播放的项目，是在73.0.3683.90版本的chrome源码上修改而来，涉及到抓取网页里视频的播放地址、播放视频、视频投屏、视频下载、网页内广告屏蔽等方面，了解到ijkplayer、GSYVideoPlayer、ffmpeg、乐播投屏、cling、NanoHttp、adblock等相关技术，现在就准备花点时间把一些技术相关的内容整理一下，分享给大家。 ...
Android基于Cling开发DLNA应用
weixin_33890526的博客
03-01 787
# Android基于Cling开发DLNA应用 ## DLNA DLNA，Digital Living Network Alliance的简称，即数字生活网络联盟。其由消费性电子、移动电话以及电脑厂商组成。目标在于创建一套可以使得各厂商的产品互相连接，互相适应的工业标准，从而为消费者实现数字化生活。 更多资料： 1. About DLNA 2. 维基百科 3...
Android UPnP框架终极指南：Cling协议栈实现与媒体播放控制详解
最新发布
gitblog_01406的博客
12-10 853
想要在Android应用中实现多屏互动、资源共享和远程控制功能吗？Cling协议栈为你提供了完整的UPnP解决方案！🎯 本文将深入解析Cling框架的源码实现，帮助你掌握设备发现、媒体推送和播放控制的核心技术。 Cling是由Java实现的DLNA/UPnP协议栈，专门用于开发支持多屏互动、资源共享和远程控制功能的Android应用。通过Cling，你可以轻松实现将手机中的音频、视频、图片推送
android cling 使用教程,Cling UPnP库为Android。关机并重新启动后没有看到设备
weixin_39882271的博客
05-31 1156
我已经找到了一些解决方案，但很遗憾有些问题里面的保鲜库。我的一些colluegue做了修复，我无法分享“修补程序库”，但不清楚哪些修改会受到影响。我们使用了补丁版本：cling-distribution-2.0.1所以可能最新的lib也已经修复了吗？ 祝你好运！ 你用2.0.1测试过吗？所以问题是：从库中的代码 成功运行：07-17 17:53:23.205 14826-14826/ I/Data...
[Android第三方类库]Cling-1.0.5 support 使用手册
Meggie_love的专栏
10-10 2816
1. 互联网网关设备（InternetGatewayDevices） 一个互联网网关设备可以连接局域网到广域网，并且可以通过UPnP协议来监控和配置局域网和广域网的接口。通常情况下这个功能是用于NAT端口映射：局域网内的客户端应用程序想要从局域网主机接收网络连接，它必须在局域网路由器上创建一个端口来做转发和映射的事情。 映射一个NAT端口 Cling支持所有必要的功能：在NA
cling-java，android的协议栈
帅子的博客
08-10 4175
译文地址：https://github.com/4thline/cling Cling 类库是由 Java 实现的 DLNA/UPnP 协议栈。这个项目的目的不但严格规范遵守，完整清晰大量的api，而且有丰富的spis用于轻松的定制化。
cling-core-2.0.1及三个依赖包，用于Java对UPnP操作的实现
03-12
cling-core-2.0.1及三个依赖包，用于Java对UPnP操作的实现 cling-core-2.0.1.jar seamless-http-1.1.1.jar seamless-util-1.1.1.jar seamless-xml-1.1.1.jar
cling-support-2.1.1.jar和cling-core-2.1.1.jar
02-21
cling-support-2.1.1.jar和cling-core-2.1.1.jar电视投屏相关工具
Android下DLNA和UPnP的研究以及问题
leolaurel的专栏
05-18 8488
因为工作的需要，最近一直在研究DLNA和UPnP，我们这里只研究多媒体的多屏互动，现在遇到瓶颈，故先总结下 DLNA确实是一个趋势，但是现在能找到的资料太少了，对我这样的新手来说难度确实大了点！！ DLNA按功能分可以分为：     DMS 数字媒体服务器   DMR数字媒体渲染器  DMC数字媒体控制器 DMP数字媒体播放器 PS:这么多天来仅仅搞定了DMP，可惜单独还无法使
Android下实现局域网设备发现与通信
gogo_wei的博客
10-17 1万+
Android下实现局域网设备发现与通信 在使用Android开发智能设备时，一般会分为用于遥控与管理的Host端，和用于执行个性功能的Slave端，二者可以借助网络或蓝牙等途径实现通信。 局域网设备发现 如果是借助网络通信，那就必须知道对方的ip地址，而常见的网络环境中ip地址一般是通过DHCP服务动态分配的，所以事先无法确定对方的ip地址。为了确定对方的地址，可以通过向局域网内发送查找设备的...
Android网络编程TCP、UDP（三）——UDP实例：搜索局域网所有的设备
Ralap Zhong的专栏
09-04 2万+
接上面的UDP，本篇主要讨论如何在局域网中搜索所有的设备，这个需求在物联网应用的比较多，也比较综合，特把名字加在标题中了。最后一块是网络编程的常见问题。3.6 实例：在局域网内搜索设备假设你家里安装了智能家居，所有的设备都是通过Wifi连接自己家里的局域网（至于这些设备没有界面操作，如何连接wifi？有一个比较流行的牛逼技术，叫SmartConfig）。现在这些设备连入到局域网了，那如何通过Andr
Android局域网通讯和查找局域网中的指定设备
05-29 6013
适用场景： 1、找到连接同一个wifi热点的对方的ip地址 2、B手机连接A手机的热点，B手机获取A手机的ip地址 思路： 由于最近项目中需要做电视与手机之间的文件互传功能，首先想到的是分享热点，彼此建立局域网连接使用Socket来传输文件，在其中遇到一个问题，手机端需要扫描局域网内可以彼此建立连接的电视，根据网上查找可以通过发送Udp广播的方式，去寻找到对方。 代码： 1、获取本机i...
android udp 设备发现,Android局域网内快速查找某个设备的IP地址（UDP通信）
weixin_28716217的博客
05-31 1289
需求：通过udp传输方式，快速找到同局域网内某设备思路：需要某设备发送，手机接收。或者手机发送，设备接收，两个设备需在同一局域网内1、建立udpsocket服务2、提供数据，并将数据封装到数据包中3、通过socket服务的发送功能，将数据包发送出去。4、关闭资源。DatagramSocket：此类表示用来发送和接收数据报包的套接字。在 DatagramSocket 上总是启用 UDP 广播发送。D...
Android 打印,搜索连接同一局域网下的所有网络打印机,打印照片,打印自定义文档。
tongzhengtong的博客
04-13 2196
Android 连接局域网下的网络打印机打印图片,和自定义文档打印。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值