当前位置：首页 > 软件库 > 手机/移动开发 > >

let

授权协议 Apache-2.0 License

开发语言 Kotlin

所属分类手机/移动开发

软件类型开源软件

地区不详

投递者柴寂离

操作系统 Android

开源组织无

适用人群未知

软件概览

Let

Annotation based simple API flavoured with AOP to handle new Android runtime permission model.

If you check Google's Samplesabout the new permission model, you'll see a lot of boiler plate code for requesting, handlingand retrying the request for required permissions.

Let will minimize the boiler plate code you have to write for requesting and handling permissions and hencehelp you keep your code more readable.

Let let Handle

Annotate your methods requiring permissions with @AskPermission and let Let handle the rest.

@AskPermission(ACCESS_FINE_LOCATION)
private void getUserLocationAndDoSomething() {
    Toast.makeText(
        SampleActivity.this, 
        "Now that I have the permission I need, I'll get your location and do something with it", 
        Toast.LENGTH_SHORT
    ).show();
    ...
}

@AskPermission({
            Manifest.permission.READ_CONTACTS,
            Manifest.permission.CALL_PHONE,
            Manifest.permission.CAMERA
})
private void skipTutorial() {
    // permissions needed for the best app experience are granted; let's go to the app's home screen
    startActivity(new Intent(this, HomeActivity.class));
}

Let will check these annotated methods and execute them unless the permissions required are granted;otherwise Let will put on hold the method execution and request these permissions at runtime. After examiningthe permission request result, Let will execute the method already put on hold only if the permissions are granted by user.

Let will also inform about the rationales before making any permission requestand tell about denied permissions; whether they're simply denied or with 'Never Ask Again' checked.

Just make sure to override the onRequestPermissionsResult in your Activity or Fragment, where your@AskPermission annotated methods are located:

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    Let.handle(this, requestCode, permissions, grantResults);
}

And make sure your Activity or Fragment implements RuntimePermissionListener in order to get notifiedabout denied permissions and rationales:

public class SampleActivity extends AppCompatActivity implements RuntimePermissionListener {
    
    // ....
    
    @Override
    public void onShowPermissionRationale(List<String> permissions, final RuntimePermissionRequest request) {
        /**
        * you may show permission rationales in a dialog, wait for user confirmation and retry the permission 
        * request by calling request.retry()    
        */               
    }
  
    @Override
    public void onPermissionDenied(List<DeniedPermission> deniedPermissionList) {
        /**
        * Do whatever you need to do about denied permissions:
        *   - update UI
        *   - if permission is denied with 'Never Ask Again', prompt a dialog to tell user
        *   to go to the app settings screen in order to grant again the permission denied 
        */              
    }
    
    //  ...
}

Usage

Add it to your project today!

buildscript {
    repositories {                    
        jcenter()        
    }

    dependencies {        
        classpath 'com.canelmas.let:let-plugin:0.1.11'
    }
}

apply plugin: 'com.android.application'
apply plugin: 'let'

repositories {        
    jcenter()
}

For kotlin :

buildscript {
    repositories {
        jcenter()
    }

    dependencies {
        classpath 'com.canelmas.let:let-plugin:1.0.0-beta1'
    }
}

apply plugin: 'com.android.application'
apply plugin: 'let'

repositories {
    jcenter()
}

Proguard

Make sure your proguard rule set includes following lines:

-keep class com.canelmas.let.** { *; }
-keepnames class * implements com.canelmas.let.RuntimePermissionListener

-keepclassmembers class * implements com.canelmas.let.RuntimePermissionListener {
    public void onRequestPermissionsResult(***);
}

-keepclasseswithmembernames class * {
    @com.canelmas.let.* <methods>;
}

License

Copyright 2016 Can Elmas

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

使用案例

ES6入门--let的基本使用

let命令基本用法 ES6新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。 { let a = 10; var b = 1; } a // ReferenceError: a is not defined. b // 1 上面代码在代码块之中，分别用let和var声明了两个变量。然后在代码块之外调用这两个变量，结果l
声明变量关键字：var、let、const的区别

var关键字定义一个变量：var操作符，后跟变量名。 var message; 这里定义了一个名为message的变量，可以用它来保存任何类型的值。未初始化的情况下，变量保存一个特殊值undefined。 var声明的范围是函数作用域当在一个函数内用var定义变量时，该变量将在函数退出时销毁： function foo() { var message = 2; } foo(); cons
JavaScript中的let是什么

let声明跟var的作用差不多，但是有着非常重要的区别。最明显的区别是： "let声明的范围是块作用域，而var声明的范围是函数作用域" if (true) { // if(里面结果为真) var name = 'Matt'; console.log(name); // Matt } console.log(name)
let和const的区别

let和const很相似 1、let和const的相同点： ①　只在声明所在的块级作用域内有效。 ②　不提升，同时存在暂时性死区，只能在声明的位置后面使用。 ③　不可重复声明。 2、let和const的不同点： ①　let声明的变量可以改变，值和类型都可以改变；const声明的常量不可以改变，这意味着，const一旦声明，就必须立即初始化，不能以后再赋值。打个比方说： let x = 3； x
let命令

1、let命令 1.1 基本用法 let命令用于声明变量，其用法类似于var，和var不同的是，所声明的变量只在let命令所在的代码快内有效。且在let的代码块中不能重复声明一个变量 { let a = 10; var b = 1; } console.log(a) // ReferenceError: a is not defined. console.log(b) // 1 上面的代码在
let和var的区别

1.var 1.1 var的赋值 var message 定义了一个名为message的变量，可以保存任何类型的值（不初始化的情况下，变量会保存一个特殊值undefined）。 var message = 'hi' 给message赋值以后，不仅能改变保存的值，还可以改变值的类型。（不推荐） 1.2 var的声明作用域使用var操作符定义的变量会成为包含它的函数的局部变量。比如，使用var在
ES6新增关键字：let和const及let的常用场景

1、ES6： ● 我们所说的ES5和ES6其实就是在js语法的发展过程中的一个版本而已 ● ECMAScript就是js的语法，ES6新增了一些功能 2、let和const关键字和var的区别 ● 我们以前都是使用var关键字来声明变量的 ● 在ES6的时候，多了两个关键字let和const，也是用来声明变量的 ● 只不过和var有一些区别：（1）let和const不允许重复声明变量 // 使
JavaScript 中 let 的使用

在 ES2015 之前，JavaScript 只有两种类型的作用域：全局作用域和函数作用域。全局（在函数之外）声明的变量拥有全局作用域，全局变量可以在 JavaScript 程序中的任何位置访问。 var carName = "porsche"; // 此处的代码可以使用 carName function myFunction() { // 此处的代码也可以使用 carN
react(let命令）

let 命令 1.let 命令基本用法 ES6新增let命令，用来生命变量。它的用法类似于var，但是所声明的变量，只是在let命令所在的代码块内有效。 { let a = 10; var b = 1; } a // ReferenceError: a is not defined. b // 1 上面代码在代码块之中，分别用let和var声明了两个变量。然后在代码块之外调用这两个变量，结果le
ES6中let命令

let命令基本用法 for (let i = 10; i >= 0; i--) { console.log(i+'------'); } console.log(i); //用let 报错 console.log(i); ^ ReferenceError: i is not defined //用var。却可以展示 10------ 9------ 8----
let 规则

/* let命令只局限于当前代码块 { let a = 0; var b=0; } alert(a); alert(b);*/ /* let不能提前解析 alert(b); let b=0; */ /* let在同一作用域不能定义相同的变量名 let b=0; let b=0; alert(b);
?. !!. ?.let和?: 的区别

一、? 与 !! 的比较 val a: String = "aa" /* * a是非空类型，下面的给a赋值为null将会编译不通过 * */ // a = null a.length /* * ？声明是可空类型，可以赋值为null * */ var b: String? = "bb" b = null
let的使用

1.let的用法类似于var。不过，所声明的变量，只在let命令所在的代码块内有效。 2.let不存在变量提升 3.暂时性死区：在代码块内，使用let命令声明变量之前，该变量是不可用的。 4.不允许重复声明。不允许在相同作用域内，重复声明同一个变量。因此，不能在函数内部重新声明参数。 //报错 function （）{ let a = 10; var a = 10; } //报错 functio
let-const

ES6–let const ES6简介 ES6-ECMAScript6：由ECMA这个标准化组织制定的一个语言标准 ES与JS的关系：JavaScript=ES（语法+API）+DOM+BOM ES6兼容性：主流浏览器的最新版本几乎全部支持ES6，IE老版本可以用Babe转码 let和const let声明变量，const声明常量用法和var一样 let，var声明变量，初始化之后还可以重新赋值
let,const,let和use strict

一.let,const和let的区别？ 1.var定义的变量，没有块的概念，可以跨块访问, 不能跨函数访问。 2.let定义的变量，只能在块作用域里访问，不能跨块访问，也不能跨函数访问。 3.const用来定义常量，使用时必须初始化(即必须赋值)，只能在块作用域里访问，而且不能修改二.严格模式('use strict') 1）'use strict'是JavaScript的严格模式 2）判断浏

let

Let

Let let Handle

Usage

Proguard

License

同类工具

相关阅读

相关文章

相关问答

相关文档