xref: /external/sl4a/Common/src/com/googlecode/android_scripting/interpreter/InterpreterConfiguration.java

/*
 * Copyright (C) 2017 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.googlecode.android_scripting.interpreter;

import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.ProviderInfo;
import android.content.pm.ResolveInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.database.Cursor;
import android.net.Uri;

import com.googlecode.android_scripting.Log;
import com.googlecode.android_scripting.SingleThreadExecutor;
import com.googlecode.android_scripting.interpreter.shell.ShellInterpreter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.ExecutorService;

/**
 * Manages and provides access to the set of available interpreters.
 *
 */
public class InterpreterConfiguration {

  private final InterpreterListener mListener;
  private final Set<Interpreter> mInterpreterSet;
  private final Set<ConfigurationObserver> mObserverSet;
  private final Context mContext;
  private volatile boolean mIsDiscoveryComplete = false;

  public interface ConfigurationObserver {
    public void onConfigurationChanged();
  }

  private class InterpreterListener extends BroadcastReceiver {
    private final PackageManager mmPackageManager;
    private final ContentResolver mmResolver;
    private final ExecutorService mmExecutor;
    private final Map<String, Interpreter> mmDiscoveredInterpreters;

    private InterpreterListener(Context context) {
      mmPackageManager = context.getPackageManager();
      mmResolver = context.getContentResolver();
      mmExecutor = new SingleThreadExecutor();
      mmDiscoveredInterpreters = new HashMap<String, Interpreter>();
    }

    private void discoverForType(final String mime) {
      mmExecutor.execute(new Runnable() {
        @Override
        public void run() {
          Intent intent = new Intent(InterpreterConstants.ACTION_DISCOVER_INTERPRETERS);
          intent.addCategory(Intent.CATEGORY_LAUNCHER);
          intent.setType(mime);
          List<ResolveInfo> resolveInfos = mmPackageManager.queryIntentActivities(intent, 0);
          for (ResolveInfo info : resolveInfos) {
            addInterpreter(info.activityInfo.packageName);
          }
          mIsDiscoveryComplete = true;
          notifyConfigurationObservers();
        }
      });
    }

    private void discoverAll() {
      mmExecutor.execute(new Runnable() {
        @Override
        public void run() {
          Intent intent = new Intent(InterpreterConstants.ACTION_DISCOVER_INTERPRETERS);
          intent.addCategory(Intent.CATEGORY_LAUNCHER);
          intent.setType(InterpreterConstants.MIME + "*");
          List<ResolveInfo> resolveInfos = mmPackageManager.queryIntentActivities(intent, 0);
          for (ResolveInfo info : resolveInfos) {
            addInterpreter(info.activityInfo.packageName);
          }
          mIsDiscoveryComplete = true;
          notifyConfigurationObservers();
        }
      });
    }

    private void notifyConfigurationObservers() {
      for (ConfigurationObserver observer : mObserverSet) {
        observer.onConfigurationChanged();
      }
    }

    private void addInterpreter(final String packageName) {
      if (mmDiscoveredInterpreters.containsKey(packageName)) {
        return;
      }
      Interpreter discoveredInterpreter = buildInterpreter(packageName);
      if (discoveredInterpreter == null) {
        return;
      }
      mmDiscoveredInterpreters.put(packageName, discoveredInterpreter);
      mInterpreterSet.add(discoveredInterpreter);
      Log.v("Interpreter discovered: " + packageName + "\nBinary: "
          + discoveredInterpreter.getBinary());
    }

    private void remove(final String packageName) {
      if (!mmDiscoveredInterpreters.containsKey(packageName)) {
        return;
      }
      mmExecutor.execute(new Runnable() {
        @Override
        public void run() {
          Interpreter interpreter = mmDiscoveredInterpreters.get(packageName);
          if (interpreter == null) {
            Log.v("Interpreter for " + packageName + " not installed.");
            return;
          }
          mInterpreterSet.remove(interpreter);
          mmDiscoveredInterpreters.remove(packageName);
          notifyConfigurationObservers();
        }
      });
    }

    // We require that there's only one interpreter provider per APK.
    private Interpreter buildInterpreter(String packageName) {
      PackageInfo packInfo;
      try {
        packInfo = mmPackageManager.getPackageInfo(packageName, PackageManager.GET_PROVIDERS);
      } catch (NameNotFoundException e) {
        throw new RuntimeException("Package '" + packageName + "' not found.");
      }
      ProviderInfo provider = packInfo.providers[0];

      Map<String, String> interpreterMap =
          getMap(provider, InterpreterConstants.PROVIDER_PROPERTIES);
      if (interpreterMap == null) {
        Log.e("Null interpreter map for: " + packageName);
        return null;
      }
      Map<String, String> environmentMap =
          getMap(provider, InterpreterConstants.PROVIDER_ENVIRONMENT_VARIABLES);
      if (environmentMap == null) {
        throw new RuntimeException("Null environment map for: " + packageName);
      }
      Map<String, String> argumentsMap = getMap(provider, InterpreterConstants.PROVIDER_ARGUMENTS);
      if (argumentsMap == null) {
        throw new RuntimeException("Null arguments map for: " + packageName);
      }
      return Interpreter.buildFromMaps(interpreterMap, environmentMap, argumentsMap);
    }

    private Map<String, String> getMap(ProviderInfo provider, String name) {
      Uri uri = Uri.parse("content://" + provider.authority + "/" + name);
      Cursor cursor = mmResolver.query(uri, null, null, null, null);
      if (cursor == null) {
        return null;
      }
      cursor.moveToFirst();
      // Use LinkedHashMap so that order is maintained (important for position CLI arguments).
      Map<String, String> map = new LinkedHashMap<String, String>();
      for (int i = 0; i < cursor.getColumnCount(); i++) {
        map.put(cursor.getColumnName(i), cursor.getString(i));
      }
      return map;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
      final String action = intent.getAction();
      final String packageName = intent.getData().getSchemeSpecificPart();
      if (action.equals(InterpreterConstants.ACTION_INTERPRETER_ADDED)) {
        mmExecutor.execute(new Runnable() {
          @Override
          public void run() {
            addInterpreter(packageName);
            notifyConfigurationObservers();
          }
        });
      } else if (action.equals(InterpreterConstants.ACTION_INTERPRETER_REMOVED)
          || action.equals(Intent.ACTION_PACKAGE_REMOVED)
          || action.equals(Intent.ACTION_PACKAGE_REPLACED)
          || action.equals(Intent.ACTION_PACKAGE_DATA_CLEARED)) {
        remove(packageName);
      }
    }

  }

  public InterpreterConfiguration(Context context) {
    mContext = context;
    mInterpreterSet = new CopyOnWriteArraySet<Interpreter>();
    mInterpreterSet.add(new ShellInterpreter());
    mObserverSet = new CopyOnWriteArraySet<ConfigurationObserver>();
    IntentFilter filter = new IntentFilter();
    filter.addAction(InterpreterConstants.ACTION_INTERPRETER_ADDED);
    filter.addAction(InterpreterConstants.ACTION_INTERPRETER_REMOVED);
    filter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED);
    filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
    filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
    filter.addDataScheme("package");
    mListener = new InterpreterListener(mContext);
    mContext.registerReceiver(mListener, filter);
  }

  public void startDiscovering() {
    mListener.discoverAll();
  }

  public void startDiscovering(String mime) {
    mListener.discoverForType(mime);
  }

  public boolean isDiscoveryComplete() {
    return mIsDiscoveryComplete;
  }

  public void registerObserver(ConfigurationObserver observer) {
    if (observer != null) {
      mObserverSet.add(observer);
    }
  }

  public void unregisterObserver(ConfigurationObserver observer) {
    if (observer != null) {
      mObserverSet.remove(observer);
    }
  }

  /**
   * Returns the list of all known interpreters.
   */
  public List<? extends Interpreter> getSupportedInterpreters() {
    return new ArrayList<Interpreter>(mInterpreterSet);
  }

  /**
   * Returns the list of all installed interpreters.
   */
  public List<Interpreter> getInstalledInterpreters() {
    List<Interpreter> interpreters = new ArrayList<Interpreter>();
    for (Interpreter i : mInterpreterSet) {
      if (i.isInstalled()) {
        interpreters.add(i);
      }
    }
    return interpreters;
  }

  /**
   * Returns the list of interpreters that support interactive mode execution.
   */
  public List<Interpreter> getInteractiveInterpreters() {
    List<Interpreter> interpreters = new ArrayList<Interpreter>();
    for (Interpreter i : mInterpreterSet) {
      if (i.isInstalled() && i.hasInteractiveMode()) {
        interpreters.add(i);
      }
    }
    return interpreters;
  }

  /**
   * Returns the interpreter matching the provided name or null if no interpreter was found.
   */
  public Interpreter getInterpreterByName(String interpreterName) {
    for (Interpreter i : mInterpreterSet) {
      if (i.getName().equals(interpreterName)) {
        return i;
      }
    }
    return null;
  }

  /**
   * Returns the correct interpreter for the provided script name based on the script's extension or
   * null if no interpreter was found.
   */
  public Interpreter getInterpreterForScript(String scriptName) {
    int dotIndex = scriptName.lastIndexOf('.');
    if (dotIndex == -1) {
      return null;
    }
    String ext = scriptName.substring(dotIndex);
    for (Interpreter i : mInterpreterSet) {
      if (i.getExtension().equals(ext)) {
        return i;
      }
    }
    return null;
  }
}