精华内容
下载资源
问答
  • 2. 复制需要安装的APK文件到Android SDK的Tools文件夹中(APK和emulator.exe同文件夹),2.3版本之后应该复制到platform-tools文件夹中。 3.进入doc命令窗口,进入android虚拟机安装目录的Tools文件夹下如: cd ..\...

    1. 首先启动Android模拟器

    2. 复制需要安装的APK文件到Android SDK的Tools文件夹中(APK和emulator.exe同文件夹),2.3版本之后应该复制到platform-tools文件夹中。

    3.进入doc命令窗口,进入android虚拟机安装目录的Tools文件夹下如: cd ..\android-sdk\tools,2.3版本之后则进入cd ..\android-sdk\platform-tools,最后执行adb install XXX.apk即可。

    释:2.3版本之后adb.exe放在了platform-tools文件夹下。

    展开全文
  • ubuntu下android虚拟机安装apk

    千次阅读 2016-08-14 13:23:46
    window下做android开发,可以用adb命令给android虚拟机安装apk软件。 在ubuntu下,给android虚拟机安装软件: 首先打开终端,cd到android SDK所在的目录下,然后进入platform-tools文件夹,ls显示文件后,你会...

    在window下做android开发,可以用adb命令给android虚拟机安装apk软件。

    在ubuntu下,给android虚拟机安装软件:

    首先打开终端,cd到android SDK所在的目录下,然后进入platform-tools文件夹,ls显示文件后,你会发现有个名为adb的可执行文件,就是用这个adb命令来为android虚拟机安装apk软件的。

    执行命令:

    ./adb install  ~/fileOpen.apk

    然后等着完成即可,这时候你会发现android虚拟机里就有了刚才安装的fileOpen.apk软件了。

    展开全文
  • ubuntu下给android虚拟机安装apk软件

    千次阅读 2012-07-19 08:59:47
    前段时间在window下做android开发,可以用adb命令给android虚拟机安装apk软件, 这段时间转到了linux下来,我用的是ubuntu,搭建好android开发环境的之后,我开始给 android虚拟机安装一些常用的软件,比如文件...

    前段时间在window下做android开发,可以用adb命令给android虚拟机安装apk软件,

    这段时间转到了linux下来,我用的是ubuntu,搭建好android开发环境的之后,我开始给

    android虚拟机安装一些常用的软件,比如文件浏览器什么的。

    首先打开终端,cd到android SDK所在的目录下,然后进入platform-tools文件夹,ls显示

    文件后,你会发现有个名为adb的可执行文件,就是用这个adb命令来为android虚拟机安装

    apk软件的。


    [plain] view plaincopyprint
    ./adb install  ~/ES_fileBrowser.apk  
    ./adb install  ~/ES_fileBrowser.apk


    然后等着完成即可,这时候你会发现android虚拟机里就有了刚才安装的ES文件浏览器了。


    install后面是apk所在路径+文件名。

    特别说明,我看见网上说的关于在linux下给android虚拟机安装apk软件的做法都不怎么适合我,

    adb可执行文件根本不在android SDK/tools/ 目录下,而是在android SDK/platform-tools/目录

    下。


     

     

    在开始教程之前,先给大家展示一下成功运行Android 4.0虚拟机的界面,经过笔者测试,体验很流畅,喜欢DIY和对开发感兴趣的朋友们可以猛击下一页,继续浏览教程。

     

     

    -------------------------------------------------------------------------------------------------

    毕业后头五年决定你的一生                                    海量Android教程、开发资料和源码

    10类最急需IT人才:Java开发者居首                   给将成为“Android高手”的10个建议 

    成为Java高手的25个学习目标--非常经典           Android 4.1果冻豆新特性详解 

    芯片巨头海思和展讯:给中国芯片业带来信心    海量经典Java教程、学习资料和源码

    Java侵权诉讼Google获胜,Android厚积薄发       面试必备:Android笔试总结 

    Android高手必须掌握的28大内容和10个建议     Android平台研发人才缺口30万 

    Android开发环境安装和配置步骤详细图解        2012国内移动App开发者大调查结果 

    Windows 7下搭建android开发环境步骤图解      Android 4.0的30个突出的新特性 

    Android高手要经过的6个阶段和6个境界           linux下搭建Android开发环境步骤 

    从IT菜鸟变为“IT骨干开发者”的11个建议        程序员编程技术迅速提高的终极攻略 

    2012世界各国人均GDP排名,中国超泰国           2012年全国各省平均工资排行 

    2012年中国大学高校排行榜(580强排名)      中国各省市面积和人口数量排名 

    中国百万开发者大调查:程序员的薪水不错     Java高手需要越过的10座高山

    周立功谈嵌入式:我的25年嵌入式生涯           Android和Java语言的异同和关系 

    华为中国区手机销量达千万,80%为智能机        谷歌Android碎片化严重

    2012年中国各省GDP和人均GDP排名              90后就业“钱景”:IT仍是最佳选择

    2012全球城市竞争力500强,69个中国城市上榜   不要做浮躁的软件工程师 

    2012年世界500强,79家大陆香港台湾公司上榜名单 给IT新兵的15个建议 

    美国知名科技公司入门级软件工程师的薪水排名  回顾Java经过的风风雨雨 

    71道经典Android面试题和答案--重要知识点都涉及到了 

    高校应届毕业生“IT业”收入最高,Android技术最热门 

     

     

     

    展开全文
  • JXM:Monitoring and Management Interface for the Java™ Platform 通过jmx可以监控vm内存使用,系统内存使用等 以下是网上某博客代码,特点是通过window和linux命令获得CPU使用率。 Java代码 利用java...

     

    JXM:Monitoring and Management Interface for the Java™ Platform

    通过jmx可以监控vm内存使用,系统内存使用等

    以下是网上某博客代码,特点是通过window和linux命令获得CPU使用率。 

     

    Java代码
    1.    利用java程序实现获取计算机cpu利用率和内存使用信息。    
    2.   
    3.     创建一个Bean用来存贮要得到的信    
    4.   
    5. public class MonitorInfoBean {    
    6.     /** 可使用内存. */    
    7.     private long totalMemory;    
    8.       
    9.     /**  剩余内存. */    
    10.     private long freeMemory;    
    11.       
    12.     /** 最大可使用内存. */    
    13.     private long maxMemory;    
    14.       
    15.     /** 操作系统. */    
    16.     private String osName;    
    17.       
    18.     /** 总的物理内存. */    
    19.     private long totalMemorySize;    
    20.       
    21.     /** 剩余的物理内存. */    
    22.     private long freePhysicalMemorySize;    
    23.       
    24.     /** 已使用的物理内存. */    
    25.     private long usedMemory;    
    26.       
    27.     /** 线程总数. */    
    28.     private int totalThread;    
    29.       
    30.     /** cpu使用率. */    
    31.     private double cpuRatio;    
    32.   
    33.     public long getFreeMemory() {    
    34.         return freeMemory;    
    35.     }    
    36.   
    37.     public void setFreeMemory(long freeMemory) {    
    38.         this.freeMemory = freeMemory;    
    39.     }    
    40.   
    41.     public long getFreePhysicalMemorySize() {    
    42.         return freePhysicalMemorySize;    
    43.     }    
    44.   
    45.     public void setFreePhysicalMemorySize(long freePhysicalMemorySize) {    
    46.         this.freePhysicalMemorySize = freePhysicalMemorySize;    
    47.     }    
    48.   
    49.     public long getMaxMemory() {    
    50.         return maxMemory;    
    51.     }    
    52.   
    53.     public void setMaxMemory(long maxMemory) {    
    54.         this.maxMemory = maxMemory;    
    55.     }    
    56.   
    57.     public String getOsName() {    
    58.         return osName;    
    59.     }    
    60.   
    61.     public void setOsName(String osName) {    
    62.         this.osName = osName;    
    63.     }    
    64.   
    65.     public long getTotalMemory() {    
    66.         return totalMemory;    
    67.     }    
    68.   
    69.     public void setTotalMemory(long totalMemory) {    
    70.         this.totalMemory = totalMemory;    
    71.     }    
    72.   
    73.     public long getTotalMemorySize() {    
    74.         return totalMemorySize;    
    75.     }    
    76.   
    77.     public void setTotalMemorySize(long totalMemorySize) {    
    78.         this.totalMemorySize = totalMemorySize;    
    79.     }    
    80.   
    81.     public int getTotalThread() {    
    82.         return totalThread;    
    83.     }    
    84.   
    85.     public void setTotalThread(int totalThread) {    
    86.         this.totalThread = totalThread;    
    87.     }    
    88.   
    89.     public long getUsedMemory() {    
    90.         return usedMemory;    
    91.     }    
    92.   
    93.     public void setUsedMemory(long usedMemory) {    
    94.         this.usedMemory = usedMemory;    
    95.     }    
    96.   
    97.     public double getCpuRatio() {    
    98.         return cpuRatio;    
    99.     }    
    100.   
    101.     public void setCpuRatio(double cpuRatio) {    
    102.         this.cpuRatio = cpuRatio;    
    103.     }    
    104. }    
    105.   
    106.     之后,建立bean的接口    
    107.   
    108. public interface IMonitorService {    
    109.     public MonitorInfoBean getMonitorInfoBean() throws Exception;    
    110.   
    111. }    
    112.   
    113.   然后,就是最关键的,得到cpu的利用率,已用内存,可用内存,最大内存等信息。    
    114.   
    115. import java.io.InputStreamReader;    
    116. import java.io.LineNumberReader;    
    117.   
    118. import sun.management.ManagementFactory;    
    119.   
    120. import com.sun.management.OperatingSystemMXBean;    
    121. import java.io.*;    
    122. import java.util.StringTokenizer;    
    123.   
    124. /**   
    125.  
    126. * 获取系统信息的业务逻辑实现类.   
    127. * @author GuoHuang   
    128. */    
    129. public class MonitorServiceImpl implements IMonitorService {    
    130.       
    131.     private static final int CPUTIME = 30;    
    132.   
    133.     private static final int PERCENT = 100;    
    134.   
    135.     private static final int FAULTLENGTH = 10;    
    136.       
    137.     private static final File versionFile = new File("/proc/version");    
    138.     private static String linuxVersion = null;    
    139.   
    140.     /**   
    141.      * 获得当前的监控对象.   
    142.      * @return 返回构造好的监控对象   
    143.      * @throws Exception   
    144.      * @author GuoHuang   
    145.      */    
    146.     public MonitorInfoBean getMonitorInfoBean() throws Exception {    
    147.         int kb = 1024;    
    148.           
    149.         // 可使用内存    
    150.         long totalMemory = Runtime.getRuntime().totalMemory() / kb;    
    151.         // 剩余内存    
    152.         long freeMemory = Runtime.getRuntime().freeMemory() / kb;    
    153.         // 最大可使用内存    
    154.         long maxMemory = Runtime.getRuntime().maxMemory() / kb;    
    155.   
    156.         OperatingSystemMXBean osmxb = (OperatingSystemMXBean) ManagementFactory    
    157.                 .getOperatingSystemMXBean();    
    158.   
    159.         // 操作系统    
    160.         String osName = System.getProperty("os.name");    
    161.         // 总的物理内存    
    162.         long totalMemorySize = osmxb.getTotalPhysicalMemorySize() / kb;    
    163.         // 剩余的物理内存    
    164.         long freePhysicalMemorySize = osmxb.getFreePhysicalMemorySize() / kb;    
    165.         // 已使用的物理内存    
    166.         long usedMemory = (osmxb.getTotalPhysicalMemorySize() - osmxb    
    167.                 .getFreePhysicalMemorySize())    
    168.                 / kb;    
    169.   
    170.         // 获得线程总数    
    171.         ThreadGroup parentThread;    
    172.         for (parentThread = Thread.currentThread().getThreadGroup(); parentThread    
    173.                 .getParent() != null; parentThread = parentThread.getParent())    
    174.             ;    
    175.         int totalThread = parentThread.activeCount();    
    176.   
    177.         double cpuRatio = 0;    
    178.         if (osName.toLowerCase().startsWith("windows")) {    
    179.             cpuRatio = this.getCpuRatioForWindows();    
    180.         }    
    181.         else {    
    182.          cpuRatio = this.getCpuRateForLinux();    
    183.         }    
    184.           
    185.         // 构造返回对象    
    186.         MonitorInfoBean infoBean = new MonitorInfoBean();    
    187.         infoBean.setFreeMemory(freeMemory);    
    188.         infoBean.setFreePhysicalMemorySize(freePhysicalMemorySize);    
    189.         infoBean.setMaxMemory(maxMemory);    
    190.         infoBean.setOsName(osName);    
    191.         infoBean.setTotalMemory(totalMemory);    
    192.         infoBean.setTotalMemorySize(totalMemorySize);    
    193.         infoBean.setTotalThread(totalThread);    
    194.         infoBean.setUsedMemory(usedMemory);    
    195.         infoBean.setCpuRatio(cpuRatio);    
    196.         return infoBean;    
    197.     }    
    198.     private static double getCpuRateForLinux(){    
    199.         InputStream is = null;    
    200.         InputStreamReader isr = null;    
    201.         BufferedReader brStat = null;    
    202.         StringTokenizer tokenStat = null;    
    203.         try{    
    204.             System.out.println("Get usage rate of CUP , linux version: "+linuxVersion);    
    205.   
    206.             Process process = Runtime.getRuntime().exec("top -b -n 1");    
    207.             is = process.getInputStream();                      
    208.             isr = new InputStreamReader(is);    
    209.             brStat = new BufferedReader(isr);    
    210.               
    211.             if(linuxVersion.equals("2.4")){    
    212.                 brStat.readLine();    
    213.                 brStat.readLine();    
    214.                 brStat.readLine();    
    215.                 brStat.readLine();    
    216.                   
    217.                 tokenStat = new StringTokenizer(brStat.readLine());    
    218.                 tokenStat.nextToken();    
    219.                 tokenStat.nextToken();    
    220.                 String user = tokenStat.nextToken();    
    221.                 tokenStat.nextToken();    
    222.                 String system = tokenStat.nextToken();    
    223.                 tokenStat.nextToken();    
    224.                 String nice = tokenStat.nextToken();    
    225.                   
    226.                 System.out.println(user+" , "+system+" , "+nice);    
    227.                   
    228.                 user = user.substring(0,user.indexOf("%"));    
    229.                 system = system.substring(0,system.indexOf("%"));    
    230.                 nice = nice.substring(0,nice.indexOf("%"));    
    231.                   
    232.                 float userUsage = new Float(user).floatValue();    
    233.                 float systemUsage = new Float(system).floatValue();    
    234.                 float niceUsage = new Float(nice).floatValue();    
    235.                   
    236.                 return (userUsage+systemUsage+niceUsage)/100;    
    237.             }else{    
    238.                 brStat.readLine();    
    239.                 brStat.readLine();    
    240.                       
    241.                 tokenStat = new StringTokenizer(brStat.readLine());    
    242.                 tokenStat.nextToken();    
    243.                 tokenStat.nextToken();    
    244.                 tokenStat.nextToken();    
    245.                 tokenStat.nextToken();    
    246.                 tokenStat.nextToken();    
    247.                 tokenStat.nextToken();    
    248.                 tokenStat.nextToken();    
    249.                 String cpuUsage = tokenStat.nextToken();    
    250.                       
    251.                   
    252.                 System.out.println("CPU idle : "+cpuUsage);    
    253.                 Float usage = new Float(cpuUsage.substring(0,cpuUsage.indexOf("%")));    
    254.                   
    255.                 return (1-usage.floatValue()/100);    
    256.             }    
    257.   
    258.                
    259.         } catch(IOException ioe){    
    260.             System.out.println(ioe.getMessage());    
    261.             freeResource(is, isr, brStat);    
    262.             return 1;    
    263.         } finally{    
    264.             freeResource(is, isr, brStat);    
    265.         }    
    266.   
    267.     }    
    268.     private static void freeResource(InputStream is, InputStreamReader isr, BufferedReader br){    
    269.         try{    
    270.             if(is!=null)    
    271.                 is.close();    
    272.             if(isr!=null)    
    273.                 isr.close();    
    274.             if(br!=null)    
    275.                 br.close();    
    276.         }catch(IOException ioe){    
    277.             System.out.println(ioe.getMessage());    
    278.         }    
    279.     }    
    280.   
    281.   
    282.     /**   
    283.      * 获得CPU使用率.   
    284.      * @return 返回cpu使用率   
    285.      * @author GuoHuang   
    286.      */    
    287.     private double getCpuRatioForWindows() {    
    288.         try {    
    289.             String procCmd = System.getenv("windir")    
    290.                     + "\\system32\\wbem\\wmic.exe process get Caption,CommandLine,"    
    291.                     + "KernelModeTime,ReadOperationCount,ThreadCount,UserModeTime,WriteOperationCount";    
    292.             // 取进程信息    
    293.             long[] c0 = readCpu(Runtime.getRuntime().exec(procCmd));    
    294.             Thread.sleep(CPUTIME);    
    295.             long[] c1 = readCpu(Runtime.getRuntime().exec(procCmd));    
    296.             if (c0 != null && c1 != null) {    
    297.                 long idletime = c1[0] - c0[0];    
    298.                 long busytime = c1[1] - c0[1];    
    299.                 return Double.valueOf(    
    300.                         PERCENT * (busytime) / (busytime + idletime))    
    301.                         .doubleValue();    
    302.             } else {    
    303.                 return 0.0;    
    304.             }    
    305.         } catch (Exception ex) {    
    306.             ex.printStackTrace();    
    307.             return 0.0;    
    308.         }    
    309.     }    
    310.   
    311.     /**        
    312.  
    313. * 读取CPU信息.   
    314.      * @param proc   
    315.      * @return   
    316.      * @author GuoHuang   
    317.      */    
    318.     private long[] readCpu(final Process proc) {    
    319.         long[] retn = new long[2];    
    320.         try {    
    321.             proc.getOutputStream().close();    
    322.             InputStreamReader ir = new InputStreamReader(proc.getInputStream());    
    323.             LineNumberReader input = new LineNumberReader(ir);    
    324.             String line = input.readLine();    
    325.             if (line == null || line.length() < FAULTLENGTH) {    
    326.                 return null;    
    327.             }    
    328.             int capidx = line.indexOf("Caption");    
    329.             int cmdidx = line.indexOf("CommandLine");    
    330.             int rocidx = line.indexOf("ReadOperationCount");    
    331.             int umtidx = line.indexOf("UserModeTime");    
    332.             int kmtidx = line.indexOf("KernelModeTime");    
    333.             int wocidx = line.indexOf("WriteOperationCount");    
    334.             long idletime = 0;    
    335.             long kneltime = 0;    
    336.             long usertime = 0;    
    337.             while ((line = input.readLine()) != null) {    
    338.                 if (line.length() < wocidx) {    
    339.                     continue;    
    340.                 }    
    341.                 // 字段出现顺序:Caption,CommandLine,KernelModeTime,ReadOperationCount,    
    342.                 // ThreadCount,UserModeTime,WriteOperation    
    343.                 String caption = Bytes.substring(line, capidx, cmdidx - 1)    
    344.                         .trim();    
    345.                 String cmd = Bytes.substring(line, cmdidx, kmtidx - 1).trim();    
    346.                 if (cmd.indexOf("wmic.exe") >= 0) {    
    347.                     continue;    
    348.                 }    
    349.                 // log.info("line="+line);    
    350.                 if (caption.equals("System Idle Process")    
    351.                         || caption.equals("System")) {    
    352.                     idletime += Long.valueOf(    
    353.                             Bytes.substring(line, kmtidx, rocidx - 1).trim())    
    354.                             .longValue();    
    355.                     idletime += Long.valueOf(    
    356.                             Bytes.substring(line, umtidx, wocidx - 1).trim())    
    357.                             .longValue();    
    358.                     continue;    
    359.                 }    
    360.   
    361.                 kneltime += Long.valueOf(    
    362.                         Bytes.substring(line, kmtidx, rocidx - 1).trim())    
    363.                         .longValue();    
    364.                 usertime += Long.valueOf(    
    365.                         Bytes.substring(line, umtidx, wocidx - 1).trim())    
    366.                         .longValue();    
    367.             }    
    368.             retn[0] = idletime;    
    369.             retn[1] = kneltime + usertime;    
    370.             return retn;    
    371.         } catch (Exception ex) {    
    372.             ex.printStackTrace();    
    373.         } finally {    
    374.             try {    
    375.                 proc.getInputStream().close();    
    376.             } catch (Exception e) {    
    377.                 e.printStackTrace();    
    378.             }    
    379.         }    
    380.         return null;    
    381.     }    
    382.       
    383.     /**     测试方法.   
    384.      * @param args   
    385.      * @throws Exception   
    386.      * @author GuoHuang   
    387.        */    
    388.     public static void main(String[] args) throws Exception {    
    389.         IMonitorService service = new MonitorServiceImpl();    
    390.         MonitorInfoBean monitorInfo = service.getMonitorInfoBean();    
    391.         System.out.println("cpu占有率=" + monitorInfo.getCpuRatio());    
    392.           
    393.         System.out.println("可使用内存=" + monitorInfo.getTotalMemory());    
    394.         System.out.println("剩余内存=" + monitorInfo.getFreeMemory());    
    395.         System.out.println("最大可使用内存=" + monitorInfo.getMaxMemory());    
    396.           
    397.         System.out.println("操作系统=" + monitorInfo.getOsName());    
    398.         System.out.println("总的物理内存=" + monitorInfo.getTotalMemorySize() + "kb");    
    399.         System.out.println("剩余的物理内存=" + monitorInfo.getFreeMemory() + "kb");    
    400.         System.out.println("已使用的物理内存=" + monitorInfo.getUsedMemory() + "kb");    
    401.         System.out.println("线程总数=" + monitorInfo.getTotalThread() + "kb");    
    402.     }    
    403. }    
    404.   
    405.     其中,Bytes类用来处理字符串    
    406.   
    407.    public class Bytes {    
    408.     public static String substring(String src, int start_idx, int end_idx){    
    409.         byte[] b = src.getBytes();    
    410.         String tgt = "";    
    411.         for(int i=start_idx; i<=end_idx; i++){    
    412.             tgt +=(char)b[i];    
    413.         }    
    414.         return tgt;    
    415.     }    
    416. }   

    转自http://jiangyongyuan.javaeye.com/blog/352053

    转载于:https://www.cnblogs.com/kungfupanda/archive/2010/01/06/1640476.html

    展开全文
  • JXM:Monitoring and Management Interface for the Java™ Platform通过jmx可以监控vm内存使用,系统内存使用等以下是网上某博客代码,特点是通过window和linux命令获得CPU使用率。利用java程序实现获取计算机cpu...
  • Platform 通过jmx可以监控vm内存使用,系统内存使用等 以下是网上某博客代码,特点是通过window和linux命令获得CPU使用率。 利用java程序实现获取计算机cpu利用率和内存使用信息。 创建一个...
  • Regardless of the platform you are working on, you will need to have Yarn installed. If you have never installed Yarn before, you can find out how at: https://yarnpkg.com/en/docs/install. Install ...
  • [linux] x server can not start under VMWare

    千次阅读 2007-04-03 16:38:00
    前些天redhat发布了最新的advanced platform,或者俗称rhel5或者as5。我下载了一份然后安装到了我的虚拟机上,VMWare的版本是5.5.2 build29772。安装没问题,但是用startx启动x window的时候,有以下错误: X Window...
  • window连接虚拟机Hadoop集群时遇到如下问题: Unable to load native-hadoop library for your platform… using builtin-Java classes where applicable 即缺少 winutils.exe 与 hadoop.dll
  • 1 , 虚拟机中下载Android源码,执行repo init -u https://android.googlesource.com/platform/manifest 时,报错 2 , 上述错误,其实是,你下的的Android源码文件放在了window和linux的共享文件夹下,导致linux...
  •  1.给个虚拟机安装oracle结果,系统给...2.yum groupinstall "Desktop" "Desktop Platform" "X Window System"     3.全部安装完成 就应该可以了 telinit 5 或者init 5 切换到runle
  • RT,在使用vs2013重新生成一个在虚拟机上的项目时候,突然跳出这个报错,报错的半个小时前才正常生成过一次,期间也就加了一两条输出语句,并未对项目生成路径有过任何操作。 错误提示如下: 错误 2 error : ...

空空如也

空空如也

1 2
收藏数 26
精华内容 10
关键字:

window虚拟机platform