如何以触摸事件和查看测量/布局使用的单位以编程方式查找屏幕尺寸？换句话说,我想在屏幕的右下角的坐标,通过触摸事件所使用的坐标系中 getRawX()/getRawY()和View.getLocationOnScreen().

我不愿意将所需的事件/视图单位称为"像素",因为在我的手机上有各种模式的"像素"概念,并且它们并没有达到一致的故事.

我看到这已经被问到并在stackoverflow和其他地方得到了很多回答,但在所有模式下,我的手机(droid 4,android 4.1.2)上没有任何答案实际可行:

• 我可以在Android应用程序中以编程方式找到屏幕宽度吗？
• 如何在android中以编程方式获取ScreenSize
• Android设置根据屏幕大小以编程方式查看可见性
• 如何在Android中获得屏幕的高度？
• 在Android中获取屏幕高度
• https://groups.google.com/forum/#!topic/android-developers/IpxnfvDFrpc
• http://shuklaxyz.blogspot.com/2012/02/how-to-programmatically-figure-out.html
• http://coderock.net/how-to-determine-screen-resolution-programmatically/
• http://www.codeproject.com/Tips/313848/Get-actual-screen-size-for-the-application-layout
• Android并以dp为单位以编程方式设置宽度和高度
• http://www.simplecodestuffs.com/how-to-get-screen-dimensions-programmatically-in-android/
• http://www.androidsnippets.com/get-size-and-orientation-of-the-screen
• http://grokbase.com/t/gg/android-developers/127aatfqb6/how-to-determine-screen-resolution-programmatically

(哇!)

这适用于需要工作的库代码,无论应用程序是否处于"屏幕兼容模式"(即清单中的targetSdkVersion <= 10),我也不想对位置,大小做任何假设,或存在状态栏或任何其他类似的屏幕装饰.

以下是事实:

1. 我的手机(机器人4运行Android 4.1.2)有540x960物理像素,即小彩色发光点.

2. 当应用程序处于屏幕比较模式时,所需单位的屏幕大小(从查看触摸事件和查看测量值)为360x640,当应用程序未处于屏幕比较模式时为540x960.这些是我需要以编程方式找到的数字,而不是用触摸事件或视图来查找它们,但是我很难找到任何会返回这些数字的API.

3. 以各种方式获得的显示和DisplayMetrics对象均声称屏幕尺寸为540x960"像素"(无论是否在屏幕比较模式下).具体来说,以下都是540x960:DisplayMetrics.{width,height} Pixels,Display.getSize(),Display.getRealSize(),Display.get {Width,Height}(),

4. 以各种方式获得的配置对象都表示屏幕{宽度,高度} Dp = 360x614(无论是否在屏幕比较模式下).我不相信这代表整个屏幕,因为宽高比是错误的.(我认为这是整个屏幕减去状态栏;我需要整个屏幕.)我认为可以说整个屏幕是360x640 dp,但我不知道任何返回640的API.

5. 以各种方式获得的DisplayMetrics表示在屏幕比较模式下"密度"为1.0f,在屏幕比较模式下为1.5f.

6. 活动 getWindow().getAttributes().{width,height} 没有帮助,因为它通常包含MATCH_PARENT 而不是实际大小.但我显然可以从一个活动中获得所需的答案 getWindow().getDecorView().getMeasured{Width,Height}() (这实际上是令人惊讶的,因为活动的窗口的decorView 看起来并不像占用了整个屏幕;它看起来像是占用了屏幕而不是状态栏).但我不想依赖于此,因为如果窗口被调整大小(软键盘出现？有人调用window.setAttributes()？或者我可能根本不在Activity中),这显然是全部错误.

我理解以下公式应该保持:pixels = dp*density当不在屏幕兼容模式时,这似乎与所有报告的数字((3),(4),(5))一致:540x960 = 360x640*1.5但在屏幕兼容模式下,它不会加起来:540x960!= 360x640*1所以,有些事情是错误的.

我认为最简单的解释是,在屏幕兼容模式下,上面(3)中列出的方法只是给出"像素"的错误答案 - 也就是说,它们的目的是返回360x640"像素",但它们是错误的返回540x960.但可能有其他方式来看待它.

在任何情况下,无论模式如何,从上面的拼图中获得所需的数字肯定是一个棘手的难题.我已经找到了一种似乎在两种模式下都可以在我的手机上工作的方式,但它非常迂回,并且它依赖于两个仍然看似相当不稳定的假设(如下面的代码注释中所述).

这是我的食谱:

/** get screen size in "pixels", i.e. touchevent/view units.
* on my droid 4, this is 360x640 …

STL提供了二进制搜索函数std :: lower_bound和std :: upper_bound,但我倾向于不使用它们,因为我无法记住它们的作用,因为它们的合同对我来说似乎完全不可思议.

只是从查看名称,我猜"lower_bound"可能是"last lower bound"的缩写,
即排序列表中的最后一个元素<=给定的val(如果有的话).
同样地,我猜"upper_bound"可能是"第一个上限"的缩写,
即排序列表中的第一个元素> =给定的val(如果有的话).

但文档说他们做了一些与此截然不同的事情 - 对我来说似乎是倒退和随机的混合.要解释doc:
- lower_bound找到第一个元素> = val
- upper_bound找到第一个元素> val

所以lower_bound根本找不到下限; 它找到了第一个上限!？并且upper_bound找到第一个严格的上限.

这有意义吗？？你怎么记得的？

一些常用的android布局,例如RelativeLayout和LinearLayout(当权重非零时)有onMeasure()实现,它们测量它们的子项两次,导致嵌套时的指数运行时间.这可以通过从叶子视图的onMeasure()中发出日志条目来轻松验证...它被称为2 ^深度时间.

有人可以给出明确和具体的描述,为什么这是？最重要的是,这种指数行为是由于整体合同的重要部分,还是只是一个可能被优化的实施细节？如果认为这是不可避免的,请举一个需要它的例子.

这样的例子将极大地帮助我和其他抱怨"保持你的布局浅"的任务是繁重的,并且想知道这是否仅仅是由核心库中尚未优化的算法驱动,或者是否确实存在阻止修复的根本困难.

也许最小的例子包括另一个LinearLayout内的LinearLayout内的Button(其中match_parent和weight = 1,触发完整的指数行为),以及一些额外的参数或情况,清楚地表明对Button的所有四个调用. onMeasure()确实有意义且必要.

我的第一个猜测是,实际上只需要两次线性时间遍历 - 第一次遍历以收集每个人的首选大小,第二次遍历来分配松弛和/或收缩.像Tex和Swing这样的世界上的其他布局引擎似乎能够经常处理具有大量对齐约束和延伸的非常深层次的层次结构,而没有任何指数爆炸,我想这就是它们的工作方式.

请注意,我不希望答案解释如何 发生指数性爆炸 - 我理解这一点,并且已经有几个帖子已经被问及并回答:

• 为什么嵌套权重不利于性能？备择方案？
• 随着层次结构的每一步,Android布局测量时间加倍
• 布局重量警告嵌套重量不良表现
• Android布局层次结构的效率
• http://android-developers.blogspot.com/2009/02/android-layout-tricks-1.html

我的问题是递归双重测量是否从根本上是必要的/合理的,如果是,我想要一个明确的解释/示例来说明原因.

编辑2013/8/22:我想也许我的问题仍未解决.这次我会试着更大胆地澄清和解释我的动机.

布局不是一个指数级的难题,正如Tex和Swing等世界上有效的布局引擎所证明的那样.

那么,LinearLayout发生了什么,android开发者社区应该如何进行响应呢？我不是要本着责备的精神,而是要理解并决定如何最好地前进.

我可以想到4种可能性:

1. 修复核心库中的性能错误,而不更改任何合同
2. 根据需要更改合同,并修复核心库中的性能错误
3. 写一个LinearLayout的替代品,它有其基本功能(即在指定比例的子项之间分配额外空间)但没有性能错误,并将其用于新的应用程序
4. 继续微观管理我们的布局,以解决其他Android开发职业的性能缺陷.

(4)对我个人来说不是一个严肃的选择.此外,我觉得在这一点上改变LinearLayout的行为是不切实际的,所以我不相信(2)也是一个严肃的选择.

离开(1)和(3).我有能力并愿意亲自去做其中任何一个,但哪一个？显然(1)如果可能的话,这是可取的 - 所以,有可能吗？这似乎是需要回答的关键阻塞问题,以确定如何向前发展.

我花了一些时间在核心代码和文档中并且它没有变得清晰,所以这就是为什么我在这里问这个问题.

如何判断对sys.stdin.readline()(或者更常见的是基于任何基于文件描述符的文件对象的readline())的调用是否会阻塞？

当我在python中编写基于行的文本过滤程序时,会出现这种情况.也就是说,程序重复从输入中读取一行文本,可能会对其进行转换,然后将其写入输出.

我想实现一个合理的输出缓冲策略.我的标准是:

1. 在批量处理数百万行时应该是有效的 - 主要是缓冲输出,偶尔刷新.
2. 在保持缓冲输出时,它永远不应阻塞输入.

因此,无缓冲输出是不好的,因为它违反了(1)(对操作系统的写入太多).并且线路缓冲输出并不好,因为它仍然违反(1)(在批量的每一百万行上将输出刷新到OS是没有意义的).并且默认缓冲输出不好,因为它违反了(2)(如果输出到文件或管道,它将不适当地保留输出).

在大多数情况下,我认为一个好的解决方案是:"刷新sys.stdout(其缓冲区已满或)sys.stdin.readline()即将阻塞".可以实施吗？

(注意,我并不认为这种策略对于所有情况都是完美的.例如,在程序受cpu约束的情况下,它可能不理想;在这种情况下,更频繁地冲洗可能是明智的,以避免在保留输出的同时进行长时间的计算.)

对于确定性,假设我在python中实现了unix的"cat -n"程序.

(实际上"cat -n"比一次一行更聪明;也就是说,它知道如何在读取整行之前读取和写入部分行;但是,对于这个例子,我要去无论如何,一次一行地实施它.)

行缓冲实现

(表现良好,但违反了标准(1),即因为冲洗太多而无法缓慢):

#!/usr/bin/python
# cat-n.linebuffered.py
import sys
num_lines_read = 0
while True:
  line = sys.stdin.readline()
  if line == '': break
  num_lines_read += 1
  print("%d: %s" % (num_lines_read, line))
  sys.stdout.flush()

默认缓冲实现

(快速但违反标准(2),即不友好的输出预扣)

#!/usr/bin/python
# cat-n.defaultbuffered.py
import sys
num_lines_read = 0
while True:
  line = sys.stdin.readline()
  if line == '': break
  num_lines_read += 1
  print("%d: %s" % (num_lines_read, line))

期望的实施:

#!/usr/bin/python
num_lines_read = 0
while True: …

我正在尝试使用java.math.BigInteger进行一些精确的整数矩阵计算,其中标量值达到数百万位.我注意到一些内置的BigInteger操作出乎意料地非常慢 - 特别是gcd的一些情况,以及更多modInverse的情况.看来我可以更快地实现我自己的这些函数版本.

我写了一个程序打印计算gcd(10 ^ n-3,10 ^ n)的时间,用于增加n的值达到一百万左右,使用内置gcd或我自己的简单替代实现:

private static java.math.BigInteger myGcd(java.math.BigInteger a, java.math.BigInteger b)
{
    a = a.abs();
    b = b.abs();
    while (true)
    {
        if (b.signum() == 0) return a;
        a = a.mod(b);
        if (a.signum() == 0) return b;
        b = b.mod(a);
    }
} // myGcd

我在ubuntu linux下使用java 8运行它,运行时版本为1.8.0_111-8u111-b14-2ubuntu0.16.04.2-b14.在Java运行时1.8.0_92的macbook上,时间相对大致相似.

内置gcd大致是二次方的:

# numDigits seconds
1 0.000005626
2 0.000008172
4 0.000002852
8 0.000003097
16 0.000019158
32 0.000026365
64 0.000058330
128 0.000488692
256 0.000148674
512 0.007579581
1024 0.001199623
2048 0.001296036
4096 0.021341193 …

xargs擅长插入初始参数：

seq 0 10 | xargs -n 3 echo foo

产生以下输出：

foo 0 1 2
foo 3 4 5
foo 6 7 8
foo 9 10

当我还想要尾随参数时该怎么办？也就是说，什么命令：

seq 0 10 | xargs -n 3 <WHAT GOES HERE?>

将产生以下期望的输出：

foo 0 1 2 bar
foo 3 4 5 bar
foo 6 7 8 bar
foo 9 10 bar

我尝试了以下方法：

seq 0 10 | xargs -n 3 -I {} echo foo {} bar

这几乎是正确的，除了它显然在每个命令行中强制使用一项，这不是我想要的：

foo 0 bar
foo 1 bar
foo 2 …

我可以简洁地（用大括号）初始化以下 6 种情况中的 5 种：

一种似乎不起作用的情况是尝试初始化仅移动对象的 std::vector ；无法编译，并显示消息，例如：“错误：调用 \'std::unique_ptr\' 的隐式删除复制构造函数”。

为什么是这样？是否有适用于这种情况的替代初始化语法？

下面的程序演示了。

/*\nclang++ -std=c++14 -W -Wall -Werror question.cc -o question\nclang++ -std=c++17 -W -Wall -Werror question.cc -o question\nclang++ -std=c++20 -W -Wall -Werror question.cc -o question\nclang++ -std=c++2b -W -Wall -Werror question.cc -o question\ng++ -std=c++14 -W -Wall -Werror question.cc -o question\ng++ -std=c++17 -W -Wall -Werror question.cc -o question\ng++ -std=c++20 -W -Wall -Werror question.cc -o …

我有以下场景：

class my_base { ... }

class my_derived : public my_base { ... };


template<typename X>
struct my_traits;

我想专门my_traits用于从my_base包括派生的所有类，例如：

template<typename Y> // Y is derived form my_base.
struct my_traits { ... };

我在添加标签、成员my_base以使其更简单方面没有问题。我已经看到了一些技巧，但我仍然感到迷茫。

如何以简单而简短的方式做到这一点？

我想我终于在大多数情况下都围绕着javascript/ES6 Promises.这并不容易!但是有些东西让我对这个设计感到困惑.

为什么Promise构造函数会进行回调？鉴于立即调用回调,调用者不能只执行该代码,从而避免一个不必要的心灵弯曲"不要打电话给我,我会打电话给你"？

以下是我所认为的Promise使用的原型示例,复制自Jake Archibald的Javascript Promises教程http://www.html5rocks.com/en/tutorials/es6/promises/#toc-promisifying-xmlhttprequest,并删除了注释.

它是XMLHttpRequest GET请求的基于Promise的包装器:

function get(url) {
  return new Promise(function(resolve, reject) {
    var req = new XMLHttpRequest();
    req.open('GET', url);
    req.onload = function() {
      if (req.status == 200) {
        resolve(req.response);
      }
      else {
        reject(Error(req.statusText));
      }
    };
    req.onerror = function() {
      reject(Error("Network Error"));
    };
    req.send();
  });
}

对我来说,上面的代码将更容易理解,如果它被重写如下,使用我正在想象的一种非常不同的承诺,具有无参数构造函数和解析/拒绝方法:

function get(url) {
  var promise = new MyEasierToUnderstandPromise();
  var req = new XMLHttpRequest();
  req.open('GET', url);
  req.onload = function() {
    if (req.status == 200) {
      promise.resolve(req.response);
    }
    else { …

我的问题是" javascript中是否可以阻止失效的侦听器问题？" 但显然"问题"这个词会导致问题.

维基百科页面说,失败的监听器问题可以通过持有对观察者的弱引用的主题来解决.我之前在Java中已经实现了它并且它运行良好,我认为我将在Javascript中实现它,但现在我不知道如何.javascript甚至有弱引用吗？我看到有WeakSet和WeakMap具有在其名称中的"弱",但他们似乎并没有被这个有帮助,据我所看到的.

这是一个jsfiddle,显示了问题的典型案例.

html:

<div id="theCurrentValueDiv">current value: false</div>
<button id="thePlusButton">+</button>

javascript:

'use strict';
console.log("starting");
let createListenableValue = function(initialValue) {
  let value = initialValue;
  let listeners = [];
  return {
    // Get the current value.
    get: function() {
      return value;
    },
    // Set the value to newValue, and call listener()
    // for each listener that has been added using addListener().
    set: function(newValue) {
      value = newValue;
      for (let listener …