工作第三周：之前的随笔

• 1:几个需求

  • 1.1:假如我们只有两个activity，如何实现界面跳转

  • 1.2:okhttp支持HTTPS怎么配置

  • 1.3:activity管理栈的好处

  • 1.4:状态的标识，杜绝用true，false

• 2: 什么是4k对齐，android打包过程术

• 3:如何判断某个view是否是在界面可见

几个需求:

假如我们只有两个activity，如何实现界面跳转

       假如界面现在需要只能有两个activity，那么也想实现界面的跳转该怎么做？如果用fragment的话那每次没有跳转的动作。如何实现？
后台我想了一下我们清淡文件中注册两个activity。在fragment切换的时候其实是通过activity的切换，但是把fragment的名字穿过去，通过反射的方式调用。

Intent intent = new Intent(ChartActivity.this,ContainActivity.class);
intent.putExtra("netfragment",clazz.getCanonicalName());
Log.e("tag","======"+clazz.getCanonicalName());
startActivity(intent);


Intent intent = getIntent();
String netfragment = intent.getStringExtra("netfragment");
//通过反射调研fragment
try {
    Fragment  f = (Fragment) Class.forName(netfragment).newInstance();
    getSupportFragmentManager().beginTransaction().add(R.id.fl_contain,f).commit();
} catch (InstantiationException e) {
    e.printStackTrace();
} catch (IllegalAccessException e) {
    e.printStackTrace();
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

       其实这时候内存中是有很多activity实例的，但是只有一种activity类，这样避免了多次的在清单文件中注册。

okhttp支持HTTPS怎么配置:

       其实setCertificates(input stream),读取证书

    private void setCertificates(InputStream... certificates) {
        try {
            CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null);
            int index = 0;
            for (InputStream certificate : certificates) {
                String certificateAlias = Integer.toString(index++);
                keyStore.setCertificateEntry(certificateAlias, certificateFactory.generateCertificate(certificate));
                try {
                    if (certificate != null)
                        certificate.close();
                } catch (IOException e) {

                }
            }
            SSLContext sslContext = SSLContext.getInstance("TLS");
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keyStore);
            sslContext.init(null, trustManagerFactory.getTrustManagers(), new SecureRandom());
            //这里初始化httpClient
            retrofit = new Retrofit.Builder()
                    .baseUrl(url)
                    .client(new OkHttpClient.Builder()
                            .sslSocketFactory(sslContext.getSocketFactory())
                            .build())
                    .addConverterFactory(GsonConverterFactory.create())
                    .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                    .build();
            service = retrofit.create(YisudaService.class);

        } catch (Exception e) {
            e.printStackTrace();
        }


    }
调用的话：
setCertificates(this.getResources().openRawResource(R.raw.tomcat));

activity管理栈的好处

public synchronized void addActivity(Activity activity) {

   if (activityStack == null) {
      activityStack = new Stack<Activity>();
   }

   Log.v(TAG, activity.getClass().getSimpleName() + "===>>>>>> 添加新的实例成功");
   activityStack.add(activity);

   MobclickAgent.setScenarioType(activity, MobclickAgent.EScenarioType.E_UM_NORMAL);

}

       每次添加的一个activity都用一个强引用引用这样可以保证处于stop，pause的activity不至于没存不足的时候被系统销毁掉。

状态的标示，杜绝用true，false

       
为什么开发中杜绝用true，false作为标识？
在我们平时的开发中经常会遇到根据某个状态进行不同的逻辑操作，很多时候我们为了方便直接使用true，false，但是这样有个问题，本来自可能只有两个状态（比如，已扫描，未扫描），随着业务的拓展，我们的状态越来越多，现在加了“强扫描”状态，由于之前用true，false区分的，现在又多了状态，我们得把以前的代码全部修改，任务量极大，有的同学或者直接用“0”，“1”，“2”加以区分，这样相比于前者是有进步，但是你不觉得这么对换个人维护是个成本极高的事吗？鬼知道你“0”，“1”，“2”是什么意思。有经验的开发相比于初级开发区别在于，开发中我们就应该尽量避规这些可能会潜在并稍微注意就可以避规的风险，
如果不这么用，那用什么比较好呢？
我给的建议是用枚举，尽管移动端不像服务器端那么不考虑内存，Google也建议少使用枚举(具体为什么少使用枚举请看我另一篇博客http://blog.csdn.net/u012070360/article/details/59529535，每个枚举项都会被声明成静态变量)，但是那点内存与代码的质量，拓展延伸，健壮，美观，作权衡我还是更倾向于用“不被看好的”枚举。

 public enum Status {
        noScan,
        hasScan,
        strongScan;

        public static String getName(Status status) {
            return getName(status.ordinal());
        }

        public static String getName(int id) {
            if (noScan.ordinal() == id) {
                return "未扫";
            } else if (hasScan.ordinal() == id) {
                return "已扫";
            } else if (strongScan.ordinal() == id) {
                return "强扫";
            }
            return "";
        }

    }

使用的时候我们只需要这么设置，简单，直观，健壮，可拓展都得到了提升。。。

 entity.setScanFlag(PartnerLoadingEntity.Status.noScan.ordinal());

什么是4k对齐，android打包过程术

先弄清楚一个概念
什么叫“在4个字节边界上对齐”，这个就是android应用程序在安装到系统的时候编译器会以4个字节作为一个单位进行读取的结果，cpu能对变量进行更高更快的访问，这样的话，效率相比较未对齐要高。

Android SDK中包含一个“zipalign”的工具，它能够对打包的应用程序进行优化。在你的应用程序上运行zipalign，使得在运行时Android与应用程序间的交互更加有效率。因此，这种方式能够让应用程序和整个系统运行得更快。我们强烈推荐在新的和已经发布的程序上使用zipalign工具来得到优化后的版本——即使你的程序是在老版本的Android平台下开发的。这篇文章将描述zipalign如何有助于性能改善以及如何使用它来优化你的app。
在Android中，每个应用程序中储存的数据文件都会被多个进程访问：安装程序会读取应用程序的manifest文件来处理与之相关的权限问题；Home应用程序会读取资源文件来获取应用程序的名和图标；系统服务会因为很多种原因读取资源（例如，显示应用程序的Notification）；此外，就是应用程序自身用到资源文件。

从未对齐的apk中读取资源比较慢且花费较多内存。最好的情况是，Home程序和未对齐的程序启动得比对齐后的慢（这也是唯一可见的效果）。最坏的情况是，安装一些未对齐资源的应用程序会增加内存压力，并因此造成系统反复地启动和杀死进程。最终，用户放弃使用如此慢又耗电的设备。

在Android中，当资源文件通过内存映射对齐到4字节边界时，访问资源文件的代码才是有效率的。但是，如果资源本身没有进行对齐处理（未使用zipalign工具），它就必须回到老路上，显式地读取它们——这个过程将会比较缓慢且会花费额外的内存。

在Android中，当资源文件通过内存映射对齐到4字节边界时，访问资源文件的代码才是有效率的。但是，如果资源本身没有进行对齐处理（未使用zipalign工具），它就必须回到老路上，显式地读取它们——这个过程将会比较缓慢且会花费额外的内存。
对于应用程序开发者来说，这种显式读取方式是相当便利的。它允许使用一些不同的开发方法，包括正常流程中不包含对齐的资源，因此，这种读取方式具有很大的便利性（本段的原始意思请参考原文）。
遗憾的是，对于用户来说，这个情况恰恰是相反的——从未对齐的apk中读取资源比较慢且花费较多内存。最好的情况是，Home程序和未对齐的程序启动得比对齐后的慢（这也是唯一可见的效果）。最坏的情况是，安装一些未对齐资源的应用程序会增加内存压力，并因此造成系统反复地启动和杀死进程。最终，用户放弃使用如此慢又耗电的设备。
幸运的是，对应用程序中的资源作对齐操作很简单：
· 使用ADT：
o 如果你使用导出向导的话，Eclipse中的ADT插件（从Ver. 0.9.3开始）就能自动对齐Release程序包。使用向导，右击工程属性，选择“Android Tools” > “Export Signed Application Package…”。当然，你还可以通过AndroidManifest.xml编辑器的第一页做到。
· 使用Ant：
o Ant编译脚本（从Android 1.6开始）可以对齐程序包。老平台的版本不能通过Ant编译脚本进行对齐，必须手动对齐。
o 从Android 1.6开始，Debug模式下编译时，Ant自动对齐和签名程序包。
o Release模式下，如果有足够的信息签名程序包的话，Ant才会执行对齐操作，因为对齐处理发生在签名之后。为了能够签名程序包，进而执行对齐操作，Ant必须知道keystore的位置以及build.properties中key的名字。相应的属性名为key.store和key.alias。如果这些属性为空，签名工具会在编译过程中提示输入store/key的密码，然后脚本会执行签名及apk文件的对齐。如果这些属性都没有，Release程序包不会进行签名，自然也就不会进行对齐了。
· 手动：
o 为了能够手动对齐程序包，Android 1.6及以后的SDK的tools/文件夹下都有zipalign工具。你可以使用它来对齐任何版本下的程序包。你必须在签名apk文件后进行，使用以下命令：zipalign -v 4 source.apk destination.apk
· 验证对齐：
o 以下的命令用于检查程序包是否进行了对齐：zipalign -c -v 4 application.apk
我们极力推荐手动zipalign你的应用程序，并确保将最新对齐后的版本提供给用户。此外，别忘了还有你的新应用程序也需要这么做！

---

下面是参考某网友的：我觉得比较好，就拿来了

安卓的构建的流程

主要有以下几步：

主要的资源文件（layout, values 等）都被 aapt 编译，并且在一个 R 文件中引用

1. Java 代码被 Java 编译器编译成 JVM 字节码(.class 文件)
2. JVM 字节码再被 dex 工具转换成 dalvik 字节码(.dex 文件)
3. 然后这些 .dex 文件、编译过的资源文件和其他资源文件（比如图片）会被打包成一个 apk
4. apk 文件在安装前会被 debug/release 的 key 文件签名
5. 安装到设备

几个注意点

上面的步骤中第一步注意是主要的资源文件，有些特别的资源文件就不会被编译，比如 assets 目录下的文件，raw 目录下的文件还有图片，都不会被编译。只不过 raw 下的文件会在 R 文件里生成 id

http://blog.csdn.net/luoshengyang/article/details/8744683

如果对 apk 正式签名，还需要使用 zipalign 工具对 apk 进行对齐操作，这样做的好处是当应用运行时会减少内存的开销

通过上面的介绍可以看到，这么复杂的构建过程如果需要人手动去完成未免太过残忍，于是有了各种的构建工具。

Android 构建的旧爱：Ant, Maven

Ant 2000 年发布，很快成为 Java 项目最流行的构建工具。

Ant 的优点就是：
- 简单、易学，不需要什么特殊准备就能上手
- 基于过程式编程思想使得构建非常灵活
- 后来还能支持插件。

不足之处就是使用 XML 作为脚本配置格式，除非是很小的项目，否则它的 XML 文件很快就大得无法管理。

Maven

Maven 也是使用 XML 作为构建配置的文件格式，不过文件结构却有了巨大的变化：

Ant 需要开发者将执行 task 所需的全部命令都列出来
而 Maven 依靠约定并提供现成的可调用的目标
不仅如此，Maven 更重要的一个进步是具备从网络上自动下载依赖的能力（当然 Ant 后来通过 Ivy 也具备了这个功能），这革命性地改变了我们开发软件的方式。

Maven 的缺点是：

依赖管理不能很好地处理相同库文件不同版本之间的冲突（Ivy在这方面更好一些）
XML 作为配置文件的格式有严格的结构层次和标准，定制化目标很困难
Maven 主要解决了依赖管理的问题，然而使用 XML 的错误使它重蹈覆辙，实际上用 Maven 很难写出复杂、定制化的构建脚本，在大型项目中，它经常什么“特别的”事还没干就有几百行代码，甚至不如 Ant。

前辈们在反省前两种构建工具的错误之后，提出了 DSL （Domain Special Language, 领域专用语言）的概念，目标是设计一套能够解决特定领域问题的语言。在构建这方面，DSL 的一个成功案例就是 Gradle。

2012 年发布的 Gradle 深刻吸取前面几位前辈的经验和教训，集大家之所成，做了很多改进。

Gradle 有约定优于配置的原则，即为设置和属性提供默认值，这使得它比 Ant 或者 Maven 更容易上手。

Gradle 构建脚本不再使用 xml ，而是使用基于 Groovy 的 DSL 进行书写（Groovy 是一种基于 Java 虚拟机的动态语言，因此 Android 开发者看着会很熟悉），从而使得构建脚本比用 Ant 和 Maven 写的更清晰、简洁，下面是实现同样目标的 Maven 代码和 Gradle 代码对比：

Gradle 既有 Ant 的强大和灵活，又有 Maven 的依赖管理，支持插件且易于使用。因此一推出就获得广泛关注，2013 年被 Google 选为 Android Studio 的默认构建工具。

Gradle 设计的方式使得它可以很容易地扩展构建和插入到现有的构建过程中，Google 推广 Gradle 和 Android Studio 时，目标是让代码复用、构建 variant、配置和定制构建过程变得更加简单。

有人可能担心是否需要专门去学习新语言 Groovy，《Gradle for Android》书中专门提到：

Groovy 代码非常易读，如果你学习过 Java，那么学习 Groovy 的曲线不会陡峭。
如果你想构建自己的任务和插件，那么对 Groovy 有更深层次的理解尤为重要。
不过因为 Groovy 是基于 Java 虚拟机的，所以你完全可以用 Java 或者其他基于 Java 虚拟机的语言来编写你的自定义插件。
Gradle 的关键概念及构建生命周期

Gradle 中两个关键的概念：项目和任务。

每个 build.gradle 构建脚本文件代表一个项目 project:

上图我并没有使用 wrapper，是因为当你运行 gradlew 命令时，gradle wrapper 会自动下载需要但是你没有的 gradle 版本并使用。
这在多人协作时，很可能因为别人修改了 gradle 版本、上传到 Git，然后导致你运行命令时需要下载半天。

不过官方还是推荐使用 wrapper，毕竟这样更稳定。

使用 gradle wrapper 以后，gradle wrapper 会为每个项目下载一个 gradle 压缩包，路径在 \Users\yourname.gradle\wrapper\dists 里：

总结
Android Studio 占领市场后，构建工具 Gradle 的地位无人能比，我们有必要学习、使用它来为我们创造价值。

这篇文章对比 Ant 和 Maven 泛泛而谈了 Gradle 的一些优点，在理解 Gradle 为什么会被使用、它有什么优点之后，有助于我们后续深入学习 Gradle 的使用。

遇到的问题

Execution failed for task ‘:app:zipalignDevRelease’.

Process ‘command ‘/Users/zew/Library/Android/sdk/build-tools/24.0.0/zipalign” finished with non-zero exit value 1
在安卓打包的时候老是出现这个bug？
今天项目没动什么地方就出现了
Error:Execution failed for task ‘:app:zipalignDebug’. > Process ‘command ‘D:\sdk1\build-tools\23.0.1\zipalign.exe” finished with non-zero exit value 1错误，
我的解决方案：我是clean 在rebuild一下就解决了
网友解决方案：后来看网上的一些网友的问题是：
而且clean 也提示
Error:Execution failed for task ‘:app:clean’. > Unable to delete file:XXX错误
更新了sdk，换版本什么的也没用，
最后才发现 clean错误是因为XXX文件被占用，才报错（之前因为用到了debug.apk，所以这个文件被占用）
value 1这个错误可以有很多原因导致，如果和clean错误同时出现，那很可能是XXX文件被占用，
如果还不行就强杀调Java进程重启as

如何判断某个view是否是在界面可见

public class MainActivity extends AppCompatActivity {

    private VideoView vv;
    private ScrollView mScrollView;
    private TextView mTextView;
    private int mScreenHeight;
    private int mScreenWeight;
    private Rect mRect;
    private boolean isReady;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        WindowManager windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
        Point point = new Point();
        windowManager.getDefaultDisplay().getSize(point);
        mScreenHeight = point.y;
        mScreenWeight = point.x;
        System.out.println(mScreenHeight+"");
        System.out.println(mScreenWeight+"");
        initViews();
    }

    private void initViews() {
        mScrollView= (ScrollView) findViewById(R.id.sv);
        mTextView= (TextView) findViewById(R.id.tv1);
        mRect = new Rect(0,0,mScreenWeight,mScreenHeight );
        mScrollView.setOnScrollChangeListener(new View.OnScrollChangeListener() {
            @Override
            public void onScrollChange(View view, int i, int i1, int i2, int i3) {
                if(mTextView.getLocalVisibleRect(mRect)){
                    if (isReady) {
                        isReady=false;
                        System.out.println("控件在屏幕显示范围内");
                    }
                }else{
                    if (!isReady){
                        isReady=true;
                        System.out.println("控件在屏幕显示范围外");
                    }
                }
            }
        });
    }
}