API tools faq
paste
Guest User

Untitled

a guest
Oct 18th, 2017
73
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.42 KB | None | 0 0
raw download clone embed print report
  1. private String getTopPackageName() {
  2.  
  3.  
  4. if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
  5. UsageStatsManager usm = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
  6. long time = System.currentTimeMillis();
  7. List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time-1000*1000, time);
  8. if (appList != null && appList.size() > 0) {
  9. SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
  10. for (UsageStats usageStats : appList) {
  11. mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
  12. }
  13. if (mySortedMap != null && !mySortedMap.isEmpty()) {
  14. currentApp = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
  15. }
  16. }
  17. } else {
  18. mActivityManager = (ActivityManager)this.getSystemService(Context.ACTIVITY_SERVICE);
  19. List<ActivityManager.RunningAppProcessInfo> tasks = mActivityManager.getRunningAppProcesses();
  20. currentApp = tasks.get(0).processName;
  21. }
  22.  
  23. return currentApp;
  24.  
  25. public class AppLockService extends Service {
  26.  
  27. public static final String BROADCAST_SERVICE_STARTED = "com.appslocker.locker.intent.action.service_started";
  28. /**
  29. * Sent to {@link MainActivity} when the service has been stopped
  30. */
  31. public static final String BROADCAST_SERVICE_STOPPED = "com.appslocker.locker.intent.action.service_stopped";
  32. /**
  33. * This category allows the receiver to receive actions relating to the
  34. * state of the service, such as when it is started or stopped
  35. */
  36. public static final String CATEGORY_STATE_EVENTS = "com.appslocker.locker.intent.category.service_start_stop_event";
  37.  
  38. private static final int REQUEST_CODE = 0x1234AF;
  39. public static final int NOTIFICATION_ID = 0xABCD32;
  40. private static final String TAG = "AppLockService";
  41.  
  42. /**
  43. * Use this action to stop the intent
  44. */
  45. private static final String ACTION_STOP = "com.apsscloker.locker.intent.action.stop_lock_service";
  46. /**
  47. * Starts the alarm
  48. */
  49. private static final String ACTION_START = "com.appslocker.locker.intent.action.start_lock_service";
  50. /**
  51. * When specifying this action, the service will initialize everything
  52. * again.<br>
  53. * This has only effect if the service was explicitly started using
  54. * {@link #getRunIntent(Context)}
  55. */
  56. private static final String ACTION_RESTART = "com.appslocker.locker.intent.action.restart_lock_service";
  57.  
  58. private static final String EXTRA_FORCE_RESTART = "com.appslocker.locker.intent.extra.force_restart";
  59. private ActivityManager mActivityManager;
  60.  
  61. /**
  62. * 0 for disabled
  63. */
  64. private long mShortExitMillis;
  65.  
  66. private boolean mRelockScreenOff;
  67. private boolean mShowNotification;
  68.  
  69. private boolean mExplicitStarted;
  70. private boolean mAllowDestroy;
  71. private boolean mAllowRestart;
  72. private Handler mHandler;
  73. private BroadcastReceiver mScreenReceiver;
  74. private String currentApp;
  75. /**
  76. * This map contains locked apps in the form<br>
  77. * <PackageName, ShortExitEndTime>
  78. */
  79. private Map<String, Boolean> mLockedPackages;
  80. private Map<String, Runnable> mUnlockMap;
  81.  
  82. @Override
  83. public IBinder onBind(Intent i) {
  84. return new LocalBinder();
  85. }
  86.  
  87. public class LocalBinder extends Binder {
  88. public AppLockService getInstance() {
  89. return AppLockService.this;
  90. }
  91. }
  92.  
  93. private final class ScreenReceiver extends BroadcastReceiver {
  94.  
  95. @Override
  96. public void onReceive(Context context, Intent intent) {
  97. if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
  98. Log.i(TAG, "Screen ON");
  99. // Trigger package again
  100. mLastPackageName = "";
  101. startAlarm(AppLockService.this);
  102. }
  103. if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
  104. Log.i(TAG, "Screen OFF");
  105. stopAlarm(AppLockService.this);
  106. if (mRelockScreenOff) {
  107. lockAll();
  108. }
  109. }
  110. }
  111. }
  112.  
  113. ;
  114.  
  115. @Override
  116. public void onCreate() {
  117. super.onCreate();
  118. Log.d(TAG, "onCreate");
  119.  
  120. }
  121.  
  122. /**
  123. * Starts everything, including notification and repeating alarm
  124. *
  125. * @return True if all OK, false if the service is not allowed to start (the
  126. * caller should stop the service)
  127. */
  128. private boolean init() {
  129. Log.d(TAG, "init");
  130. if (new PrefUtils(this).isCurrentPasswordEmpty()) {
  131. Log.w(TAG, "Not starting service, current password empty");
  132. return false;
  133. }
  134.  
  135.  
  136. mHandler = new Handler();
  137. mActivityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
  138.  
  139. mUnlockMap = new HashMap<>();
  140. mLockedPackages = new HashMap<>();
  141. mScreenReceiver = new ScreenReceiver();
  142. IntentFilter filter = new IntentFilter();
  143. filter.addAction(Intent.ACTION_SCREEN_ON);
  144. filter.addAction(Intent.ACTION_SCREEN_OFF);
  145. registerReceiver(mScreenReceiver, filter);
  146.  
  147. final Set<String> apps = PrefUtils.getLockedApps(this);
  148. for (String s : apps) {
  149. mLockedPackages.put(s, true);
  150. }
  151. PrefUtils prefs = new PrefUtils(this);
  152. boolean delay = prefs.getBoolean(R.string.pref_key_delay_status,
  153. R.bool.pref_def_delay_status);
  154.  
  155. if (delay) {
  156. int secs = prefs.parseInt(R.string.pref_key_delay_time,
  157. R.string.pref_def_delay_time);
  158. mShortExitMillis = secs * 1000;
  159. }
  160.  
  161. mRelockScreenOff = prefs.getBoolean(
  162. R.string.pref_key_relock_after_screenoff,
  163. R.bool.pref_def_relock_after_screenoff);
  164.  
  165. startNotification();
  166. startAlarm(this);
  167.  
  168. // Tell MainActivity we're done
  169. Intent i = new Intent(BROADCAST_SERVICE_STARTED);
  170. i.addCategory(CATEGORY_STATE_EVENTS);
  171. sendBroadcast(i);
  172. return true;
  173. }
  174.  
  175. @Override
  176. public int onStartCommand(Intent intent, int flags, int startId) {
  177. // Log.d(TAG, "test");
  178. if (intent == null || ACTION_START.equals(intent.getAction())) {
  179. if (!mExplicitStarted) {
  180. Log.d(TAG, "explicitStarted = false");
  181. if (init() == false) {
  182. doStopSelf();
  183. return START_NOT_STICKY;
  184. }
  185. mExplicitStarted = true;
  186. }
  187. checkPackageChanged();
  188. } else if (ACTION_RESTART.equals(intent.getAction())) {
  189. if (mExplicitStarted
  190. || intent.getBooleanExtra(EXTRA_FORCE_RESTART, false)) {
  191. Log.d(TAG,
  192. "ACTION_RESTART (force="
  193. + intent.getBooleanExtra(EXTRA_FORCE_RESTART,
  194. false));
  195. // init();
  196. doRestartSelf(); // not allowed, so service will restart
  197. } else {
  198. doStopSelf();
  199. }
  200. } else if (ACTION_STOP.equals(intent.getAction())) {
  201. Log.d(TAG, "ACTION_STOP");
  202. doStopSelf();
  203. }
  204.  
  205. return START_STICKY;
  206. }
  207.  
  208. private String mLastPackageName;
  209.  
  210.  
  211. private void checkPackageChanged() {
  212. final String packageName = getTopPackageName();
  213. // final String completeName = packageName + "/"
  214. // + top.topActivity.getShortClassName();
  215.  
  216. if (!packageName.equals(mLastPackageName)) {
  217. Log.d(TAG, "appchanged " + " (" + mLastPackageName + ">"
  218. + packageName + ")");
  219.  
  220. onAppClose(mLastPackageName, packageName);
  221. onAppOpen(packageName, mLastPackageName);
  222. }
  223.  
  224. // prepare for next call
  225. mLastPackageName = packageName;
  226. // mLastCompleteName = completeName;
  227. }
  228.  
  229. private void onAppOpen(final String open, final String close) {
  230. if (mLockedPackages.containsKey(open)) {
  231. onLockedAppOpen(open);
  232. }
  233. }
  234.  
  235. private void onLockedAppOpen(final String open) {
  236. final boolean locked = mLockedPackages.get(open);
  237. // Log.d(TAG, "onLockedAppOpen (locked=" + locked + ")");
  238. if (locked) {
  239. showLocker(open);
  240. }
  241. removeRelockTimer(open);
  242. }
  243.  
  244. private void showLocker(String packageName) {
  245. Intent intent = LockService.getLockIntent(getApplicationContext(), packageName);
  246. intent.setAction(LockService.ACTION_COMPARE);
  247. intent.putExtra(LockService.EXTRA_PACKAGENAME, packageName);
  248. startService(intent);
  249.  
  250. }
  251.  
  252. private void showLockerForCategory(String category) {
  253. Intent intent = LockService.getLockIntentForCategory(this, category);
  254. intent.setAction(LockService.ACTION_COMPARE);
  255. intent.putExtra(LockService.EXTRA_CATEGORY, category);
  256. startService(intent);
  257.  
  258. }
  259.  
  260. private void onAppClose(String close, String open) {
  261. if (mLockedPackages.containsKey(close)) {
  262. onLockedAppClose(close, open);
  263. }
  264. }
  265.  
  266. private void onLockedAppClose(String close, String open) {
  267. //showInterstitial();
  268.  
  269. setRelockTimer(close);
  270.  
  271. if (getPackageName().equals(close) || getPackageName().equals(open)) {
  272. // Don't interact with own app
  273. return;
  274. }
  275.  
  276. if (mLockedPackages.containsKey(open)) {
  277. // The newly opened app needs a lock screen, so don't hide previous
  278. return;
  279. }
  280. LockService.hide(this);
  281. }
  282.  
  283. private void setRelockTimer(String packageName) {
  284. boolean locked = mLockedPackages.get(packageName);
  285. if (!locked) {
  286. if (mShortExitMillis != 0) {
  287. Runnable r = new RelockRunnable(packageName);
  288. mHandler.postDelayed(r, mShortExitMillis);
  289. mUnlockMap.put(packageName, r);
  290. } else {
  291. lockApp(packageName);
  292. }
  293. }
  294. }
  295.  
  296. private void removeRelockTimer(String packageName) {
  297. // boolean locked = mLockedPackages.get(packageName);
  298. // if (!locked) {
  299. if (mUnlockMap.containsKey(packageName)) {
  300. mHandler.removeCallbacks(mUnlockMap.get(packageName));
  301. mUnlockMap.remove(packageName);
  302. }
  303. }
  304.  
  305. /**
  306. * This class will re-lock an app
  307. */
  308. private class RelockRunnable implements Runnable {
  309. private final String mPackageName;
  310.  
  311. public RelockRunnable(String packageName) {
  312. mPackageName = packageName;
  313. }
  314.  
  315. @Override
  316. public void run() {
  317. lockApp(mPackageName);
  318. }
  319. }
  320.  
  321. List<RunningTaskInfo> mTestList = new ArrayList<>();
  322.  
  323.  
  324. private String getTopPackageName() {
  325.  
  326.  
  327. if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
  328. UsageStatsManager usm = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
  329. long time = System.currentTimeMillis();
  330. List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time-1000*1000, time);
  331. if (appList != null && appList.size() > 0) {
  332. SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
  333. for (UsageStats usageStats : appList) {
  334. mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
  335. }
  336. if (mySortedMap != null && !mySortedMap.isEmpty()) {
  337. currentApp = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
  338. }
  339. }
  340. } else {
  341. mActivityManager = (ActivityManager)this.getSystemService(Context.ACTIVITY_SERVICE);
  342. List<ActivityManager.RunningAppProcessInfo> tasks = mActivityManager.getRunningAppProcesses();
  343. currentApp = tasks.get(0).processName;
  344. }
  345.  
  346. return currentApp;
  347.  
  348. /* if (Build.VERSION.SDK_INT > 20) {
  349. return mActivityManager.getRunningAppProcesses().get(0).processName;
  350. // mClassName = activityManager.getRunningAppProcesses().get(0).getClass().getName();
  351. } else {
  352. return mActivityManager.getRunningTasks(1).get(0).topActivity.getPackageName();
  353. // mClassName = activityManager.getRunningTasks(1).get(0).topActivity.getClassName();
  354. }*/
  355.  
  356. }
  357.  
  358. public void unlockApp(String packageName) {
  359. Log.d(TAG, "unlocking app (packageName=" + packageName + ")");
  360. if (mLockedPackages.containsKey(packageName)) {
  361. mLockedPackages.put(packageName, false);
  362. }
  363. }
  364.  
  365. private void lockAll() {
  366. for (Map.Entry<String, Boolean> entry : mLockedPackages.entrySet()) {
  367. entry.setValue(true);
  368. }
  369. }
  370.  
  371. void lockApp(String packageName) {
  372. if (mLockedPackages.containsKey(packageName)) {
  373. mLockedPackages.put(packageName, true);
  374. }
  375. }
  376.  
  377. private void startNotification() {
  378.  
  379. // Start foreground anyway
  380. startForegroundWithNotification();
  381.  
  382. mShowNotification = new PrefUtils(this).getBoolean(
  383. R.string.pref_key_show_notification,
  384. R.bool.pref_def_show_notification);
  385.  
  386. }
  387.  
  388. @SuppressLint("InlinedApi")
  389. private void startForegroundWithNotification() {
  390. Log.d(TAG, "showNotification");
  391.  
  392. boolean hide = new PrefUtils(this).getBoolean(
  393. R.string.pref_key_hide_notification_icon,
  394. R.bool.pref_def_hide_notification_icon);
  395. int priority = hide ? Notification.PRIORITY_MIN
  396. : Notification.PRIORITY_DEFAULT;
  397. Intent i = new Intent(this, MainActivity.class);
  398. PendingIntent pi = PendingIntent.getActivity(this, 0, i, 0);
  399. String title = getString(R.string.notification_title);
  400. String content = getString(R.string.notification_state_locked);
  401. NotificationCompat.Builder nb = new NotificationCompat.Builder(this);
  402. nb.setSmallIcon(R.drawable.ic_launcher);
  403. nb.setContentTitle(title);
  404. nb.setContentText(content);
  405. nb.setWhen(System.currentTimeMillis());
  406. nb.setContentIntent(pi);
  407. nb.setOngoing(true);
  408. nb.setPriority(priority);
  409.  
  410. startForeground(NOTIFICATION_ID, nb.build());
  411. }
  412.  
  413. public static void start(Context c) {
  414. startAlarm(c);
  415. }
  416.  
  417. /**
  418. * @param c
  419. * @return The new state for the service, true for running, false for not
  420. * running
  421. */
  422. public static boolean toggle(Context c) {
  423. if (isRunning(c)) {
  424. stop(c);
  425. return false;
  426. } else {
  427. start(c);
  428. return true;
  429. }
  430.  
  431. }
  432.  
  433. public static boolean isRunning(Context c) {
  434. ActivityManager manager = (ActivityManager) c
  435. .getSystemService(Context.ACTIVITY_SERVICE);
  436. for (RunningServiceInfo service : manager
  437. .getRunningServices(Integer.MAX_VALUE)) {
  438. if (AppLockService.class.getName().equals(
  439. service.service.getClassName())) {
  440. return true;
  441. }
  442. }
  443. return false;
  444. }
  445.  
  446. /**
  447. * Starts the service
  448. */
  449. private static void startAlarm(Context c) {
  450. AlarmManager am = (AlarmManager) c.getSystemService(ALARM_SERVICE);
  451. PendingIntent pi = getRunIntent(c);
  452. SharedPreferences sp = PrefUtils.prefs(c);
  453. String defaultPerformance = c.getString(R.string.pref_val_perf_normal);
  454. String s = sp.getString(c.getString(R.string.pref_key_performance),
  455. defaultPerformance);
  456. if (s.length() == 0)
  457. s = "0";
  458. long interval = Long.parseLong(s);
  459. Log.d(TAG, "Scheduling alarm (interval=" + interval + ")");
  460. long startTime = SystemClock.elapsedRealtime();
  461. am.setRepeating(AlarmManager.ELAPSED_REALTIME, startTime, interval, pi);
  462. }
  463.  
  464. private static PendingIntent running_intent;
  465.  
  466. private static PendingIntent getRunIntent(Context c) {
  467. if (running_intent == null) {
  468. Intent i = new Intent(c, AppLockService.class);
  469. i.setAction(ACTION_START);
  470. running_intent = PendingIntent.getService(c, REQUEST_CODE, i, 0);
  471. }
  472. return running_intent;
  473. }
  474.  
  475. private static void stopAlarm(Context c) {
  476. AlarmManager am = (AlarmManager) c.getSystemService(ALARM_SERVICE);
  477. am.cancel(getRunIntent(c));
  478. }
  479.  
  480. /**
  481. * Stop this service, also stopping the alarm
  482. */
  483. public static void stop(Context c) {
  484. stopAlarm(c);
  485. Intent i = new Intent(c, AppLockService.class);
  486. i.setAction(ACTION_STOP);
  487. c.startService(i);
  488. }
  489.  
  490. /**
  491. * Re-initialize everything.<br>
  492. * This has only effect if the service was explicitly started using
  493. * {@link #start(Context)}
  494. */
  495. public static void restart(Context c) {
  496. Intent i = new Intent(c, AppLockService.class);
  497. i.setAction(ACTION_RESTART);
  498. c.startService(i);
  499. }
  500.  
  501. /**
  502. * Forces the service to stop and then start again. This means that if the
  503. * service was already stopped, it will just start
  504. */
  505. public static void forceRestart(Context c) {
  506. Intent i = new Intent(c, AppLockService.class);
  507. i.setAction(ACTION_RESTART);
  508. i.putExtra(EXTRA_FORCE_RESTART, true);
  509. c.startService(i);
  510. }
  511.  
  512. @Override
  513. public void onDestroy() {
  514. super.onDestroy();
  515. Log.d(TAG, "onDestroy: (mAllowRestart=" + mAllowRestart + ")");
  516. if (mScreenReceiver != null)
  517. unregisterReceiver(mScreenReceiver);
  518. if (mShowNotification)
  519. stopForeground(true);
  520.  
  521. if (mAllowRestart) {
  522. start(this);
  523. mAllowRestart = false;
  524. return;
  525. }
  526.  
  527. Log.i(TAG, "onDestroy (mAllowDestroy=" + mAllowDestroy + ")");
  528. if (!mAllowDestroy) {
  529. Log.d(TAG, "Destroy not allowed, restarting service");
  530. start(this);
  531. } else {
  532. // Tell MainActivity we're stopping
  533. Intent i = new Intent(BROADCAST_SERVICE_STOPPED);
  534. i.addCategory(CATEGORY_STATE_EVENTS);
  535. sendBroadcast(i);
  536. }
  537. mAllowDestroy = false;
  538. }
  539.  
  540. private void doStopSelf() {
  541. stopAlarm(this);
  542. mAllowDestroy = true;
  543. stopForeground(true);
  544. stopSelf();
  545. }
  546.  
  547. private void doRestartSelf() {
  548. Log.d(TAG, "Setting allowrestart to true");
  549. mAllowRestart = true;
  550. stopSelf();
  551. }
  552.  
  553. <uses-sdk
  554. android:minSdkVersion="15"
  555. android:targetSdkVersion="23" />
  556.  
  557. <supports-screens
  558. android:anyDensity="true"
  559. android:largeScreens="true"
  560. android:normalScreens="true"
  561. android:smallScreens="true" />
  562.  
  563. <uses-feature
  564. android:name="android.hardware.telephony"
  565. android:required="false" />
  566. <uses-feature
  567. android:name="android.hardware.usb.accessory"
  568. android:required="false" />
  569. <uses-feature
  570. android:name="android.hardware.usb.host"
  571. android:required="false" />
  572. <uses-feature
  573. android:name="android.hardware.location"
  574. android:required="false" />
  575. <uses-feature
  576. android:name="android.hardware.wifi"
  577. android:required="false" />
  578.  
  579. <!-- permissions -->
  580. <uses-permission android:name="android.permission.GET_TASKS" />
  581. <uses-permission android:name="android.permission.PACKAGE_USAGE_STATS" tools:ignore="ProtectedPermissions" />
  582. <uses-permission android:name="android.permission.VIBRATE" />
  583. <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
  584. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  585. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  586. <uses-permission android:name="android.permission.MANAGE_DOCUMENTS" />
  587. <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
  588. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  589. <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  590.  
  591. <application
  592. android:allowBackup="false"
  593. android:icon="@drawable/ic_launcher"
  594. android:label="@string/application_name"
  595. android:theme="@style/Theme.AppCompat"
  596. android:largeHeap="true"
  597. tools:node="replace">
  598. <activity
  599. android:name="com.appslocker.locker.ui.MainActivity"
  600. android:label="@string/application_name">
  601. <intent-filter>
  602. <action android:name="android.intent.action.MAIN" />
  603. <action android:name="android.intent.action.SEARCH" />
  604.  
  605. <category android:name="android.intent.category.LAUNCHER" />
  606. </intent-filter>
  607. </activity>
  608.  
  609. <service android:name="com.appslocker.locker.lock.AppLockService" />
  610. <service android:name="com.appslocker.locker.lock.LockService" />
  611.  
  612. <receiver android:name="com.appslocker.locker.receivers.BootCompleteReceiver">
  613. <intent-filter>
  614. <action android:name="android.intent.action.BOOT_COMPLETED" />
  615. <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
  616. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLE_REQUESTED" />
  617. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLED" />
  618. </intent-filter>
  619. </receiver>
  620. <receiver
  621. android:name=".DeviceAdmenReciever"
  622. android:permission="android.permission.BIND_DEVICE_ADMIN">
  623. <meta-data
  624. android:name="android.app.device_admin"
  625. android:resource="@xml/device_admin" />
  626.  
  627. <intent-filter>
  628. <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
  629. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLE_REQUESTED" />
  630. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLED" />
  631. </intent-filter>
  632. </receiver>
  633.  
  634. <meta-data
  635. android:name="com.google.android.gms.version"
  636. android:value="@integer/google_play_services_version" />
  637.  
  638. <service
  639. android:name=".MyAccessibilityService"
  640. android:label="@string/accessibility_service_label"
  641. android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE" >
  642. <intent-filter>
  643. <action android:name="android.accessibilityservice.AccessibilityService" />
  644. </intent-filter>
  645.  
  646. <meta-data
  647. android:name="android.accessibilityservice"
  648. android:resource="@xml/accessibility_service_config" />
  649. </service>
  650.  
  651.  
  652. </application>
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!