kotlin sample module

sample-kotlin/.gitignore

@@ -0,0 +1 @@
+/build

sample-kotlin/build.gradle

@@ -0,0 +1,36 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion COMPILE_SDK_VERSION
+    buildToolsVersion BUILD_TOOLS_VERSION
+    defaultConfig {
+        applicationId "permissions.dispatcher.samplekotlin"
+        targetSdkVersion TARGET_SDK_VERSION
+        minSdkVersion MIN_SDK_VERSION
+        versionCode 1
+        versionName "1.0"
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+kapt {
+    generateStubs = true
+}
+
+dependencies {
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$KOTLIN_VERSION"
+    compile "com.android.support:appcompat-v7:$SUPPORT_LIBRARY_VERSION"
+    compile (project(':library')) {
+        exclude module: "support-v13"
+    }
+    compile project(':processor')
+
+    kapt project(':processor')
+}

sample-kotlin/src/main/AndroidManifest.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="permissions.dispatcher.samplekotlin">
+
+    <uses-permission android:name="android.permission.CAMERA"/>
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme" >
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

sample-kotlin/src/main/java/permissions/dispatcher/samplekotlin/MainActivity.kt

@@ -0,0 +1,102 @@
+package permissions.dispatcher.samplekotlin
+
+import android.Manifest
+import android.os.Bundle
+import android.support.annotation.StringRes
+import android.support.v7.app.AlertDialog
+import android.support.v7.app.AppCompatActivity
+import android.view.View
+import android.widget.Toast
+import permissions.dispatcher.*
+import permissions.dispatcher.samplekotlin.camera.CameraPreviewFragment
+import permissions.dispatcher.samplekotlin.contacts.ContactsFragment
+
+@RuntimePermissions
+class MainActivity : AppCompatActivity(), View.OnClickListener {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        findViewById(R.id.button_camera).setOnClickListener(this)
+        findViewById(R.id.button_contacts).setOnClickListener(this)
+    }
+
+    override fun onClick(v: View) {
+        when (v.id) {
+            R.id.button_camera -> {
+                // NOTE: delegate the permission handling to generated method
+                MainActivityPermissionsDispatcher.showCameraWithCheck(this)
+            }
+
+            R.id.button_contacts -> {
+                // NOTE: delegate the permission handling to generated method
+                MainActivityPermissionsDispatcher.showContactsWithCheck(this)
+            }
+
+        }
+    }
+
+    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        // NOTE: delegate the permission handling to generated method
+        MainActivityPermissionsDispatcher.onRequestPermissionsResult(this, requestCode, grantResults)
+    }
+
+    @NeedsPermission(Manifest.permission.CAMERA)
+    fun showCamera() {
+        // NOTE: Perform action that requires the permission. If this is run by PermissionsDispatcher, the permission will have been granted
+        supportFragmentManager.beginTransaction()
+                .replace(R.id.sample_content_fragment, CameraPreviewFragment.newInstance())
+                .addToBackStack("camera")
+                .commitAllowingStateLoss()
+    }
+
+    @NeedsPermission(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)
+    fun showContacts() {
+        // NOTE: Perform action that requires the permission.
+        // If this is run by PermissionsDispatcher, the permission will have been granted
+        supportFragmentManager.beginTransaction()
+                .replace(R.id.sample_content_fragment, ContactsFragment.newInstance())
+                .addToBackStack("contacts")
+                .commitAllowingStateLoss()
+    }
+
+    @OnShowRationale(Manifest.permission.CAMERA)
+    fun showRationaleForCamera(request: PermissionRequest) {
+        // NOTE: Show a rationale to explain why the permission is needed, e.g. with a dialog.
+        // Call proceed() or cancel() on the provided PermissionRequest to continue or abort
+        showRationaleDialog(R.string.permission_camera_rationale, request)
+    }
+
+    @OnShowRationale(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)
+    fun showRationaleForContact(request: PermissionRequest) {
+        // NOTE: Show a rationale to explain why the permission is needed, e.g. with a dialog.
+        // Call proceed() or cancel() on the provided PermissionRequest to continue or abort
+        showRationaleDialog(R.string.permission_contacts_rationale, request)
+    }
+
+    @OnPermissionDenied(Manifest.permission.CAMERA)
+    fun onCameraDenied() {
+        // NOTE: Deal with a denied permission, e.g. by showing specific UI
+        // or disabling certain functionality
+        Toast.makeText(this, R.string.permission_camera_denied, Toast.LENGTH_SHORT).show()
+    }
+
+    @OnNeverAskAgain(Manifest.permission.CAMERA)
+    fun onCameraNeverAskAgain() {
+        Toast.makeText(this, R.string.permission_camera_never_askagain, Toast.LENGTH_SHORT).show()
+    }
+
+    fun onBackClick(view: View) {
+        supportFragmentManager.popBackStack()
+    }
+
+    private fun showRationaleDialog(@StringRes messageResId: Int, request: PermissionRequest) {
+        AlertDialog.Builder(this)
+                .setPositiveButton(R.string.button_allow) { dialog, which -> request.proceed() }
+                .setNegativeButton(R.string.button_deny) { dialog, which -> request.cancel() }
+                .setCancelable(false)
+                .setMessage(messageResId)
+                .show()
+    }
+}

sample-kotlin/src/main/java/permissions/dispatcher/samplekotlin/camera/CameraPreview.java

@@ -0,0 +1,150 @@
+/*
+* Copyright 2015 The Android Open Source Project
+*
+* 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.
+*/
+
+package permissions.dispatcher.samplekotlin.camera;
+
+import android.content.Context;
+import android.hardware.Camera;
+import android.util.Log;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+
+import java.io.IOException;
+
+/**
+ * Camera preview that displays a {@link Camera}.
+ *
+ * Handles basic lifecycle methods to display and stop the preview.
+ * <p>
+ * Implementation is based directly on the documentation at
+ * http://developer.android.com/guide/topics/media/camera.html
+ */
+public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
+
+    private static final String TAG = "CameraPreview";
+    private SurfaceHolder mHolder;
+    private Camera mCamera;
+    private Camera.CameraInfo mCameraInfo;
+    private int mDisplayOrientation;
+
+    public CameraPreview(Context context, Camera camera, Camera.CameraInfo cameraInfo,
+            int displayOrientation) {
+        super(context);
+
+        // Do not initialise if no camera has been set
+        if (camera == null || cameraInfo == null) {
+            return;
+        }
+        setCamera(camera, cameraInfo, displayOrientation);
+
+        // Install a SurfaceHolder.Callback so we get notified when the
+        // underlying surface is created and destroyed.
+        mHolder = getHolder();
+        mHolder.addCallback(this);
+    }
+
+    public void surfaceCreated(SurfaceHolder holder) {
+        // The Surface has been created, now tell the camera where to draw the preview.
+        try {
+            mCamera.setPreviewDisplay(holder);
+            mCamera.startPreview();
+            Log.d(TAG, "Camera preview started.");
+        } catch (IOException e) {
+            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
+        }
+    }
+
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        // empty. Take care of releasing the Camera preview in your activity.
+    }
+
+    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
+        // If your preview can change or rotate, take care of those events here.
+        // Make sure to stop the preview before resizing or reformatting it.
+
+        if (mHolder.getSurface() == null) {
+            // preview surface does not exist
+            Log.d(TAG, "Preview surface does not exist");
+            return;
+        }
+
+        // stop preview before making changes
+        try {
+            mCamera.stopPreview();
+            Log.d(TAG, "Preview stopped.");
+        } catch (Exception e) {
+            // ignore: tried to stop a non-existent preview
+            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
+        }
+
+        int orientation = calculatePreviewOrientation(mCameraInfo, mDisplayOrientation);
+        mCamera.setDisplayOrientation(orientation);
+
+        try {
+            mCamera.setPreviewDisplay(mHolder);
+            mCamera.startPreview();
+            Log.d(TAG, "Camera preview started.");
+        } catch (Exception e) {
+            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Calculate the correct orientation for a {@link Camera} preview that is displayed on screen.
+     *
+     * Implementation is based on the sample code provided in
+     * {@link Camera#setDisplayOrientation(int)}.
+     */
+    public static int calculatePreviewOrientation(Camera.CameraInfo info, int rotation) {
+        int degrees = 0;
+
+        switch (rotation) {
+            case Surface.ROTATION_0:
+                degrees = 0;
+                break;
+            case Surface.ROTATION_90:
+                degrees = 90;
+                break;
+            case Surface.ROTATION_180:
+                degrees = 180;
+                break;
+            case Surface.ROTATION_270:
+                degrees = 270;
+                break;
+        }
+
+        int result;
+        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
+            result = (info.orientation + degrees) % 360;
+            result = (360 - result) % 360;  // compensate the mirror
+        } else {  // back-facing
+            result = (info.orientation - degrees + 360) % 360;
+        }
+
+        return result;
+    }
+
+    public void setCamera(Camera camera, Camera.CameraInfo cameraInfo, int displayOrientation) {
+        // Do not reinitialise if no camera has been set
+        if (camera == null || cameraInfo == null) {
+            return;
+        }
+        mCamera = camera;
+        mCameraInfo = cameraInfo;
+        mDisplayOrientation = displayOrientation;
+    }
+}