gametel 0.1

data/ApiDemos/src/com/example/android/apis/accessibility/CustomViewAccessibilityActivity.java

@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2011 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 com.example.android.apis.accessibility;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.Layout;
+import android.text.StaticLayout;
+import android.text.TextPaint;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.View;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+
+import com.example.android.apis.R;
+
+/**
+ * Demonstrates how to implement accessibility support of custom views. Custom view
+ * is a tailored widget developed by extending the base classes in the android.view
+ * package. This sample shows how to implement the accessibility behavior via both
+ * inheritance (non backwards compatible) and composition (backwards compatible).
+ * <p>
+ * While the Android framework has a diverse portfolio of views tailored for various
+ * use cases, sometimes a developer needs a specific functionality not implemented
+ * by the standard views. A solution is to write a custom view that extends one the
+ * base view classes. While implementing the desired functionality a developer should
+ * also implement accessibility support for that new functionality such that
+ * disabled users can leverage it.
+ * </p>
+ */
+public class CustomViewAccessibilityActivity extends Activity {
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.custom_view_accessibility);
+    }
+
+    /**
+     * Demonstrates how to enhance the accessibility support via inheritance.
+     * <p>
+     * <strong>Note:</strong> Using inheritance may break your application's
+     * backwards compatibility. In particular, overriding a method that takes as
+     * an argument or returns a class not present on an older platform
+     * version will prevent your application from running on that platform.
+     * For example, {@link AccessibilityNodeInfo} was introduced in
+     * {@link Build.VERSION_CODES#ICE_CREAM_SANDWICH API 14}, thus overriding
+     * {@link View#onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo)
+     *  View.onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo)}
+     * will prevent you application from running on a platform older than
+     * {@link Build.VERSION_CODES#ICE_CREAM_SANDWICH API 14}.
+     * </p>
+     */
+    public static class AccessibleCompoundButtonInheritance extends BaseToggleButton {
+
+        public AccessibleCompoundButtonInheritance(Context context, AttributeSet attrs) {
+            super(context, attrs);
+        }
+
+        @Override
+        public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
+            super.onInitializeAccessibilityEvent(event);
+            // We called the super implementation to let super classes
+            // set appropriate event properties. Then we add the new property
+            // (checked) which is not supported by a super class.
+            event.setChecked(isChecked());
+        }
+
+        @Override
+        public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
+            super.onInitializeAccessibilityNodeInfo(info);
+            // We called the super implementation to let super classes set
+            // appropriate info properties. Then we add our properties
+            // (checkable and checked) which are not supported by a super class.
+            info.setCheckable(true);
+            info.setChecked(isChecked());
+            // Very often you will need to add only the text on the custom view.
+            CharSequence text = getText();
+            if (!TextUtils.isEmpty(text)) {
+                info.setText(text);
+            }
+        }
+
+        @Override
+        public void onPopulateAccessibilityEvent(AccessibilityEvent event) {
+            super.onPopulateAccessibilityEvent(event);
+            // We called the super implementation to populate its text to the
+            // event. Then we add our text not present in a super class.
+            // Very often you will need to add only the text on the custom view.
+            CharSequence text = getText();
+            if (!TextUtils.isEmpty(text)) {
+                event.getText().add(text);
+            }
+        }
+    }
+
+    /**
+     * Demonstrates how to enhance the accessibility support via composition.
+     * <p>
+     * <strong>Note:</strong> Using composition ensures that your application is
+     * backwards compatible. The android-support-v4 library has API that allow
+     * using the accessibility APIs in a backwards compatible manner.
+     * </p>
+     */
+    public static class AccessibleCompoundButtonComposition extends BaseToggleButton {
+
+        public AccessibleCompoundButtonComposition(Context context, AttributeSet attrs) {
+            super(context, attrs);
+            tryInstallAccessibilityDelegate();
+        }
+
+        public void tryInstallAccessibilityDelegate() {
+            // If the API version of the platform we are running is too old
+            // and does not support the AccessibilityDelegate APIs, do not
+            // call View.setAccessibilityDelegate(AccessibilityDelegate) or
+            // refer to AccessibilityDelegate, otherwise an exception will
+            // be thrown.
+            // NOTE: The android-support-v4 library contains APIs the enable
+            // using the accessibility APIs in a backwards compatible fashion.
+            if (Build.VERSION.SDK_INT < 14) {
+                return;
+            }
+            // AccessibilityDelegate allows clients to override its methods that
+            // correspond to the accessibility methods in View and register the
+            // delegate in the View essentially injecting the accessibility support.
+            setAccessibilityDelegate(new AccessibilityDelegate() {
+                @Override
+                public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
+                    super.onInitializeAccessibilityEvent(host, event);
+                    // We called the super implementation to let super classes
+                    // set appropriate event properties. Then we add the new property
+                    // (checked) which is not supported by a super class.
+                    event.setChecked(isChecked());
+                }
+
+                @Override
+                public void onInitializeAccessibilityNodeInfo(View host,
+                        AccessibilityNodeInfo info) {
+                    super.onInitializeAccessibilityNodeInfo(host, info);
+                    // We called the super implementation to let super classes set
+                    // appropriate info properties. Then we add our properties
+                    // (checkable and checked) which are not supported by a super class.
+                    info.setCheckable(true);
+                    info.setChecked(isChecked());
+                    // Very often you will need to add only the text on the custom view.
+                    CharSequence text = getText();
+                    if (!TextUtils.isEmpty(text)) {
+                        info.setText(text);
+                    }
+                }
+
+                @Override
+                public void onPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
+                    super.onPopulateAccessibilityEvent(host, event);
+                    // We called the super implementation to populate its text to the
+                    // event. Then we add our text not present in a super class.
+                    // Very often you will need to add only the text on the custom view.
+                    CharSequence text = getText();
+                    if (!TextUtils.isEmpty(text)) {
+                        event.getText().add(text);
+                    }
+                }
+            });
+        }
+    }
+
+    /**
+     * This is a base toggle button class whose accessibility is not tailored
+     * to reflect the new functionality it implements.
+     * <p>
+     * <strong>Note:</strong> This is not a sample implementation of a toggle
+     * button, rather a simple class needed to demonstrate how to refine the
+     * accessibility support of a custom View.
+     * </p>
+     */
+    private static class BaseToggleButton extends View {
+        private boolean mChecked;
+
+        private CharSequence mTextOn;
+        private CharSequence mTextOff;
+
+        private Layout mOnLayout;
+        private Layout mOffLayout;
+
+        private TextPaint mTextPaint;
+
+        public BaseToggleButton(Context context, AttributeSet attrs) {
+            this(context, attrs, android.R.attr.buttonStyle);
+        }
+
+        public BaseToggleButton(Context context, AttributeSet attrs, int defStyle) {
+            super(context, attrs, defStyle);
+
+            mTextPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
+
+            TypedValue typedValue = new TypedValue();
+            context.getTheme().resolveAttribute(android.R.attr.textSize, typedValue, true);
+            final int textSize = (int) typedValue.getDimension(
+                    context.getResources().getDisplayMetrics());
+            mTextPaint.setTextSize(textSize);
+
+            context.getTheme().resolveAttribute(android.R.attr.textColorPrimary, typedValue, true);
+            final int textColor = context.getResources().getColor(typedValue.resourceId);
+            mTextPaint.setColor(textColor);
+
+            mTextOn = context.getString(R.string.accessibility_custom_on);
+            mTextOff = context.getString(R.string.accessibility_custom_off);
+        }
+
+        public boolean isChecked() {
+            return mChecked;
+        }
+
+        public CharSequence getText() {
+            return mChecked ? mTextOn : mTextOff;
+        }
+
+        @Override
+        public boolean performClick() {
+            final boolean handled = super.performClick();
+            if (!handled) {
+                mChecked ^= true;
+                invalidate();
+            }
+            return handled;
+        }
+
+        @Override
+        public void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+            if (mOnLayout == null) {
+                mOnLayout = makeLayout(mTextOn);
+            }
+            if (mOffLayout == null) {
+                mOffLayout = makeLayout(mTextOff);
+            }
+            final int minWidth = Math.max(mOnLayout.getWidth(), mOffLayout.getWidth())
+                    + getPaddingLeft() + getPaddingRight();
+            final int minHeight = Math.max(mOnLayout.getHeight(), mOffLayout.getHeight())
+                    + getPaddingLeft() + getPaddingRight();
+            setMeasuredDimension(resolveSizeAndState(minWidth, widthMeasureSpec, 0),
+                    resolveSizeAndState(minHeight, heightMeasureSpec, 0));
+        }
+
+        private Layout makeLayout(CharSequence text) {
+            return new StaticLayout(text, mTextPaint,
+                    (int) Math.ceil(Layout.getDesiredWidth(text, mTextPaint)),
+                    Layout.Alignment.ALIGN_NORMAL, 1.f, 0, true);
+        }
+
+        @Override
+        protected void onDraw(Canvas canvas) {
+            super.onDraw(canvas);
+            canvas.save();
+            canvas.translate(getPaddingLeft(), getPaddingRight());
+            Layout switchText = mChecked ? mOnLayout : mOffLayout;
+            switchText.draw(canvas);
+            canvas.restore();
+        }
+    }
+}

data/ApiDemos/src/com/example/android/apis/accessibility/TaskBackService.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2011 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 com.example.android.apis.accessibility;
+
+import com.example.android.apis.R;
+
+import android.accessibilityservice.AccessibilityService;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityRecord;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.TextToSpeech.OnInitListener;
+
+import java.util.Locale;
+
+/**
+ * This class demonstrates how an accessibility service can query
+ * window content to improve the feedback given to the user.
+ */
+public class TaskBackService extends AccessibilityService implements OnInitListener {
+
+    /** Tag for logging. */
+    private static final String LOG_TAG = "TaskBackService/onAccessibilityEvent";
+
+    /** Comma separator. */
+    private static final String SEPARATOR = ", ";
+
+    /** The class name of TaskListView - for simplicity we speak only its items. */
+    private static final String TASK_LIST_VIEW_CLASS_NAME =
+        "com.example.android.apis.accessibility.TaskListView";
+
+    /** Flag whether Text-To-Speech is initialized. */
+    private boolean mTextToSpeechInitialized;
+
+    /** Handle to the Text-To-Speech engine. */
+    private TextToSpeech mTts;
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void onServiceConnected() {
+        // Initializes the Text-To-Speech engine as soon as the service is connected.
+        mTts = new TextToSpeech(getApplicationContext(), this);
+    }
+
+    /**
+     * Processes an AccessibilityEvent, by traversing the View's tree and
+     * putting together a message to speak to the user.
+     */
+    @Override
+    public void onAccessibilityEvent(AccessibilityEvent event) {
+        if (!mTextToSpeechInitialized) {
+            Log.e(LOG_TAG, "Text-To-Speech engine not ready.  Bailing out.");
+            return;
+        }
+
+        // This AccessibilityNodeInfo represents the view that fired the
+        // AccessibilityEvent. The following code will use it to traverse the
+        // view hierarchy, using this node as a starting point.
+        //
+        // NOTE: Every method that returns an AccessibilityNodeInfo may return null,
+        // because the explored window is in another process and the
+        // corresponding View might be gone by the time your request reaches the
+        // view hierarchy.
+        AccessibilityNodeInfo source = event.getSource();
+        if (source == null) {
+            return;
+        }
+
+        // Grab the parent of the view that fired the event.
+        AccessibilityNodeInfo rowNode = getListItemNodeInfo(source);
+        if (rowNode == null) {
+            return;
+        }
+
+        // Using this parent, get references to both child nodes, the label and the checkbox.
+        AccessibilityNodeInfo labelNode = rowNode.getChild(0);
+        if (labelNode == null) {
+            rowNode.recycle();
+            return;
+        }
+
+        AccessibilityNodeInfo completeNode = rowNode.getChild(1);
+        if (completeNode == null) {
+            rowNode.recycle();
+            return;
+        }
+
+        // Determine what the task is and whether or not it's complete, based on
+        // the text inside the label, and the state of the check-box.
+        if (rowNode.getChildCount() < 2 || !rowNode.getChild(1).isCheckable()) {
+            rowNode.recycle();
+            return;
+        }
+
+        CharSequence taskLabel = labelNode.getText();
+        final boolean isComplete = completeNode.isChecked();
+
+        String completeStr = null;
+        if (isComplete) {
+            completeStr = getString(R.string.task_complete);
+        } else {
+            completeStr = getString(R.string.task_not_complete);
+        }
+
+        String taskStr = getString(R.string.task_complete_template, taskLabel, completeStr);
+        StringBuilder utterance = new StringBuilder(taskStr);
+
+        // The custom ListView added extra context to the event by adding an
+        // AccessibilityRecord to it. Extract that from the event and read it.
+        final int records = event.getRecordCount();
+        for (int i = 0; i < records; i++) {
+            AccessibilityRecord record = event.getRecord(i);
+            CharSequence contentDescription = record.getContentDescription();
+            if (!TextUtils.isEmpty(contentDescription )) {
+                utterance.append(SEPARATOR);
+                utterance.append(contentDescription);
+            }
+        }
+
+        // Announce the utterance.
+        mTts.speak(utterance.toString(), TextToSpeech.QUEUE_FLUSH, null);
+        Log.d(LOG_TAG, utterance.toString());
+    }
+
+    private AccessibilityNodeInfo getListItemNodeInfo(AccessibilityNodeInfo source) {
+        AccessibilityNodeInfo current = source;
+        while (true) {
+            AccessibilityNodeInfo parent = current.getParent();
+            if (parent == null) {
+                return null;
+            }
+            if (TASK_LIST_VIEW_CLASS_NAME.equals(parent.getClassName())) {
+                return current;
+            }
+            // NOTE: Recycle the infos.
+            AccessibilityNodeInfo oldCurrent = current;
+            current = parent;
+            oldCurrent.recycle();
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void onInterrupt() {
+        /* do nothing */
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void onInit(int status) {
+        // Set a flag so that the TaskBackService knows that the Text-To-Speech
+        // engine has been initialized, and can now handle speaking requests.
+        if (status == TextToSpeech.SUCCESS) {
+            mTts.setLanguage(Locale.US);
+            mTextToSpeechInitialized = true;
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (mTextToSpeechInitialized) {
+            mTts.shutdown();
+        }
+    }
+}