Tells RMP-Appirater that the app has launched.
<p/>
Show rating dialog if user isn't rating yet and don't select "Not show again".

@param context Context
@param options RMP-Appirater options.
327477
public static void appLaunched(Context context, Options options) {
        appLaunched(context, null, options, null);
    }
1179161
public boolean loadActiveConversation(Context context) {
		checkConversationQueue();

		if (context == null) {
			throw new IllegalArgumentException("Context is null");
		}

		try {
			// resolving metadata
			ApptentiveLog.v(CONVERSATION, "Resolving metadata...");
			conversationMetadata = resolveMetadata();
			if (ApptentiveLog.canLog(VERBOSE)) {
				printMetadata(conversationMetadata, "Loaded Metadata");
			}

			// attempt to load existing conversation
			ApptentiveLog.v(CONVERSATION, "Loading active conversation...");
			setActiveConversation(loadActiveConversationGuarded());

			if (activeConversation != null) {
				ApptentiveNotificationCenter.defaultCenter()
					.postNotification(NOTIFICATION_CONVERSATION_LOAD_DID_FINISH,
						NOTIFICATION_KEY_CONVERSATION, activeConversation,
						NOTIFICATION_KEY_SUCCESSFUL, true);

				activeConversation.startListeningForChanges();
				activeConversation.scheduleSaveConversationData();

				handleConversationStateChange(activeConversation);
				return true;
			}

		} catch (Exception e) {
			ApptentiveLog.e(CONVERSATION, e, "Exception while loading active conversation");
      logException(e);
      
			activeConversationFailedToResolve = true;
		}

		ApptentiveNotificationCenter.defaultCenter()
			.postNotification(NOTIFICATION_CONVERSATION_LOAD_DID_FINISH,
				NOTIFICATION_KEY_SUCCESSFUL, false);

		return false;
	}
1250206
public void setContext(Context context) {
        log = Log.instance(context);
        options = Options.instance(context);
        classLoaderClass = options.get("procloader");

        // Avoid initializing Lint
        boolean warn = options.isLintSet("path");
        locations.update(log, warn, FSInfo.instance(context));

        // Setting this option is an indication that close() should defer actually closing
        // the file manager until after a specified period of inactivity.
        // This is to accomodate clients which save references to Symbols created for use
        // within doclets or annotation processors, and which then attempt to use those
        // references after the tool exits, having closed any internally managed file manager.
        // Ideally, such clients should run the tool via the javax.tools API, providing their
        // own file manager, which can be closed by the client when all use of that file
        // manager is complete.
        // If the option has a numeric value, it will be interpreted as the duration,
        // in seconds, of the period of inactivity to wait for, before the file manager
        // is actually closed.
        // See also deferredClose().
        String s = options.get("fileManager.deferClose");
        if (s != null) {
            try {
                deferredCloseTimeout = (int) (Float.parseFloat(s) * 1000);
            } catch (NumberFormatException e) {
                deferredCloseTimeout = 60 * 1000;  // default: one minute, in millis
            }
        }
    }
955421
protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
		if (this.beanNameGenerator != null) {
			context.getBeanFactory().registerSingleton(
					AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
					this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			if (context instanceof GenericApplicationContext) {
				((GenericApplicationContext) context)
						.setResourceLoader(this.resourceLoader);
			}
			if (context instanceof DefaultResourceLoader) {
				((DefaultResourceLoader) context)
						.setClassLoader(this.resourceLoader.getClassLoader());
			}
		}
		if (this.addConversionService) {
			context.getBeanFactory().setConversionService(
					ApplicationConversionService.getSharedInstance());
		}
	}
1319551
public static void setDoNotShowAgain(Context context, boolean doNotShowAgain) {
        SharedPreferences prefs = getSharedPreferences(context);
        SharedPreferences.Editor prefsEditor = prefs.edit();

        prefsEditor.putBoolean(PREF_KEY_DO_NOT_SHOW_AGAIN, doNotShowAgain);

        prefsEditor.commit();
    }
1100494
@Activate
    protected void activate(ComponentContext context) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
            Tr.event(tc, "activate", context);
    }
1126582
public void startSecuritySettingsActivity(Context context) {
        if (!startDelegateActivity(context, delegate.getSecuritySettingsIntent(), null)) {
            startActivity(context, null, SecuritySettingsActivity.class);
        }
    }
183509
public static void startActivity(Context context, Intent intent,
                                     Bundle options) {
        ThemeManager.startActivity(context, intent, -1, options);
    }
1153622
public void showSettingDialog(Context context, final List<String> permissions) {
        List<String> permissionNames = Permission.transformText(context, permissions);
        String message = context.getString(R.string.message_permission_always_failed,
            TextUtils.join("\n", permissionNames));

        new AlertDialog.Builder(context).setCancelable(false)
            .setTitle(R.string.title_dialog)
            .setMessage(message)
            .setPositiveButton(R.string.setting, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    setPermission();
                }
            })
            .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                }
            })
            .show();
    }
1257012
public static void setFirstLaunchDate(Context context, long firstLaunchDate) {
        SharedPreferences prefs = getSharedPreferences(context);
        SharedPreferences.Editor prefsEditor = prefs.edit();

        prefsEditor.putLong(PREF_KEY_APP_FIRST_LAUNCHED_DATE, firstLaunchDate);

        prefsEditor.commit();
    }
680878
private void initRequestFromRpcContext(CmsContainerPageRpcContext context) {

        if (context.getTemplateContext() != null) {
            getRequest().setAttribute(
                CmsTemplateContextManager.ATTR_RPC_CONTEXT_OVERRIDE,
                context.getTemplateContext());
        }
    }
1331542
public void register(Context context) {
        if (mRegisteredContext != null) {
            throw new IllegalStateException("Already registered");
        }

        mRegisteredContext = context;
        context.registerReceiver(this, mPackageFilter);
    }
428614
@SuppressLint("RestrictedApi")
    public static void hideStatusBar(Context context) {
        if (Jzvd.TOOL_BAR_EXIST) {
            JZUtils.getWindow(context).setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        }
    }
911875
public void startAfterLoginActivity(Context context, Bundle extras) {
        if (!startDelegateActivity(context, delegate.getStartAfterLoginIntent(), extras)) {
            startMessagingActivity(context, extras);
        }
    }
579704
@Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        if (context == null) {
            synchronized (ApplicationContextHolder.class) {
                if (context == null) {
                    ApplicationContextHolder.context = applicationContext;
                }
            }
        }
    }
204807
public void addContextMenuTableListener(
        CmsContextMenu.ContextMenuOpenedListener.TableListener contextMenuTableListener) {

        addListener(
            ContextMenuOpenedOnTableRowEvent.class,
            contextMenuTableListener,
            ContextMenuOpenedListener.TableListener.MENU_OPENED_FROM_TABLE_ROW_METHOD);
        addListener(
            ContextMenuOpenedOnTableHeaderEvent.class,
            contextMenuTableListener,
            ContextMenuOpenedListener.TableListener.MENU_OPENED_FROM_TABLE_HEADER_METHOD);
        addListener(
            ContextMenuOpenedOnTableFooterEvent.class,
            contextMenuTableListener,
            ContextMenuOpenedListener.TableListener.MENU_OPENED_FROM_TABLE_FOOTER_METHOD);
    }
329355
static void reset(Context context) {
        Context appContext = context.getApplicationContext();
        String key = appContext.getString(R.string.wings__retry_policy_consecutive_fails);

        // Synchronously reset consecutive fail count.
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(appContext);
        Editor editor = preferences.edit();
        editor.putInt(key, 0);
        editor.commit();
    }