Daniel Elliott
f3960ee359
- Imported from https://github.com/supermegamestre/Project-Real-Resurrection-3 - APKTool decompilation (Smali bytecode) for modding and rebuilding APK - Supports both 32-bit (armeabi-v7a) and 64-bit (arm64-v8a) architectures - Includes full Smali source, resources, and native libraries - Ready to rebuild APK after modifications with apktool b command - Added comprehensive README-apktool.md with modding guide This branch complements the JADX branches: - Use JADX (main/discord-community) to UNDERSTAND code (readable Java) - Use APKTool (this branch) to MODIFY and REBUILD APK (editable Smali) Total: 44,417 files, 538.51 MB Smali source code
803 lines
28 KiB
Plaintext
803 lines
28 KiB
Plaintext
<script language='javascript' type='text/javascript'>
|
|
(function() {
|
|
// Establish the root mraidbridge object.
|
|
var mraidbridge = window.mraidbridge = {};
|
|
// Listeners for bridge events.
|
|
var listeners = {};
|
|
// Queue to track pending calls to the native SDK.
|
|
var nativeCallQueue = [];
|
|
// Whether a native call is currently in progress.
|
|
var nativeCallInFlight = false;
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
mraidbridge.windowLoaded = false;
|
|
mraidbridge.callbackIframe = undefined;
|
|
mraidbridge.loggingEnabled = false;
|
|
|
|
mraidbridge.log = function(msg) {
|
|
mraidbridge.loggingEnabled && console.log(msg);
|
|
}
|
|
|
|
window.addEventListener('load', function(e) {
|
|
var ifr = document.createElement('iframe');
|
|
var container = document.body || document.documentElement;
|
|
container.appendChild(ifr);
|
|
ifr.setAttribute('sandbox', '');
|
|
ifr.setAttribute('style', 'position: fixed; bottom: -20px; border: none; display: none; height: 20px; z-index: -99999');
|
|
mraidbridge.callbackIframe = ifr;
|
|
mraidbridge.windowLoaded = true;
|
|
if (nativeCallQueue.length === 0) {
|
|
return;
|
|
}
|
|
var nextCall = nativeCallQueue.pop();
|
|
nativeCallInFlight = true;
|
|
mraidbridge.callbackIframe && mraidbridge.callbackIframe.setAttribute('src', nextCall);
|
|
});
|
|
mraidbridge.fireReadyEvent = function() {
|
|
mraidbridge.fireEvent('ready');
|
|
};
|
|
mraidbridge.fireChangeEvent = function(properties) {
|
|
mraidbridge.fireEvent('change', properties);
|
|
};
|
|
mraidbridge.fireErrorEvent = function(action, message) {
|
|
mraidbridge.fireEvent('error', message, action);
|
|
mraidbridge.log("mraidBridge: fireErrorEvent with message '" + message + "' and action="+action);
|
|
};
|
|
mraidbridge.fireEvent = function(type) {
|
|
mraidbridge.log("mraidBridge: firing event of type: " + type);
|
|
var ls = listeners[type];
|
|
if (ls) {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
args.shift();
|
|
mraidbridge.log("mraidBridge: firing event of type: " + type + " with args - " + JSON.stringify(args));
|
|
var l = ls.length;
|
|
for (var i = 0; i < l; i++) {
|
|
ls[i].apply(null, args);
|
|
}
|
|
}
|
|
};
|
|
mraidbridge.nativeCallComplete = function(command) {
|
|
mraidbridge.log("mraidbridge: nativeCallComplete: " + command);
|
|
mraidbridge.log("native Call complete: " + command);
|
|
if (nativeCallQueue.length === 0) {
|
|
nativeCallInFlight = false;
|
|
return;
|
|
}
|
|
|
|
var nextCall = nativeCallQueue.pop();
|
|
mraidbridge.callbackIframe && mraidbridge.callbackIframe.setAttribute('src', nextCall);
|
|
};
|
|
mraidbridge.executeNativeCall = function(command) {
|
|
if (!mraidbridge.windowLoaded) {
|
|
mraidbridge.log("rejecting native call, window onload has not been invoked");
|
|
return;
|
|
}
|
|
var call = 'mraid://' + command;
|
|
var key, value;
|
|
var isFirstArgument = true;
|
|
for (var i = 1; i < arguments.length; i += 2) {
|
|
key = arguments[i];
|
|
value = arguments[i + 1];
|
|
if (value === null) continue;
|
|
if (isFirstArgument) {
|
|
call += '?';
|
|
isFirstArgument = false;
|
|
} else {
|
|
call += '&';
|
|
}
|
|
call += encodeURIComponent(key) + '=' + encodeURIComponent(value);
|
|
}
|
|
|
|
if (!mraidbridge.callbackIframe || nativeCallInFlight) {
|
|
nativeCallQueue.push(call);
|
|
} else {
|
|
nativeCallInFlight = true;
|
|
mraidbridge.callbackIframe && mraidbridge.callbackIframe.setAttribute('src', call);
|
|
}
|
|
};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
mraidbridge.addEventListener = function(event, listener) {
|
|
mraidbridge.log("mraidbridge: addEventListener: " + listener);
|
|
var eventListeners;
|
|
listeners[event] = listeners[event] || [];
|
|
eventListeners = listeners[event];
|
|
for (var l in eventListeners) {
|
|
// LoadListener already registered, so no need to add it.
|
|
if (listener === l) return;
|
|
}
|
|
eventListeners.push(listener);
|
|
};
|
|
mraidbridge.removeEventListener = function(event, listener) {
|
|
mraidbridge.log("mraidbridge: removeEventListener: " + listener);
|
|
if (listeners.hasOwnProperty(event)) {
|
|
var eventListeners = listeners[event];
|
|
if (eventListeners) {
|
|
var idx = eventListeners.indexOf(listener);
|
|
if (idx !== -1) {
|
|
eventListeners.splice(idx, 1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}());
|
|
(function() {
|
|
mraidbridge.log("mraidbridge: initializing mraid");
|
|
var mraid = window.mraid = {};
|
|
var bridge = window.mraidbridge;
|
|
// Constants. ////////////////////////////////////////////////////////////////////////////////////
|
|
var VERSION = mraid.VERSION = '2.0';
|
|
var STATES = mraid.STATES = {
|
|
LOADING: 'loading', // Initial state.
|
|
DEFAULT: 'default',
|
|
EXPANDED: 'expanded',
|
|
HIDDEN: 'hidden',
|
|
RESIZED: 'resized'
|
|
};
|
|
var EVENTS = mraid.EVENTS = {
|
|
ERROR: 'error',
|
|
INFO: 'info',
|
|
READY: 'ready',
|
|
STATECHANGE: 'stateChange',
|
|
VIEWABLECHANGE: 'viewableChange',
|
|
SIZECHANGE: 'sizeChange'
|
|
};
|
|
var PLACEMENT_TYPES = mraid.PLACEMENT_TYPES = {
|
|
UNKNOWN: 'unknown',
|
|
INLINE: 'inline',
|
|
INTERSTITIAL: 'interstitial'
|
|
};
|
|
// External MRAID state: may be directly or indirectly modified by the ad JS. ////////////////////
|
|
// Properties which define the behavior of an expandable ad.
|
|
var expandProperties = {
|
|
width: -1,
|
|
height: -1,
|
|
useCustomClose: false,
|
|
isModal: true,
|
|
lockOrientation: false
|
|
};
|
|
var hasSetCustomSize = false;
|
|
var hasSetCreativeSize = false;
|
|
var hasSetCreativeOffset = false;
|
|
var hasSetCustomClose = false;
|
|
var listeners = {};
|
|
// Internal MRAID state. Modified by the native SDK. /////////////////////////////////////////////
|
|
var state = STATES.LOADING;
|
|
var isViewable = false;
|
|
var screenSize = { width: -1, height: -1 };
|
|
var maxSize = { width: -1, height: -1 };
|
|
var adSize = { width: -1, height: -1 };
|
|
var currentPosition = {
|
|
x:0,
|
|
y:0,
|
|
width:0,
|
|
height:0
|
|
};
|
|
var mraidDefaultPosition = {
|
|
x:0,
|
|
y:0,
|
|
width:0,
|
|
height:0
|
|
};
|
|
// Properties which define the behavior of an resized ad.
|
|
var resizeProperties = {
|
|
width:-1,
|
|
height:-1,
|
|
customClosePosition:'top-right',
|
|
offsetX:0,
|
|
offsetY:0,
|
|
allowOffscreen:true
|
|
};
|
|
var orientationProperties = {
|
|
allowOrientationChange:true,
|
|
forceOrientation:'none'
|
|
};
|
|
var placementType = PLACEMENT_TYPES.UNKNOWN;
|
|
var supports = {
|
|
sms: false,
|
|
tel: false,
|
|
calendar: false,
|
|
storePicture: false,
|
|
inlineVideo: false
|
|
};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
var EventListeners = function(event) {
|
|
this.event = event;
|
|
this.count = 0;
|
|
var listeners = {};
|
|
this.add = function(func) {
|
|
var id = String(func);
|
|
if (!listeners[id]) {
|
|
listeners[id] = func;
|
|
this.count++;
|
|
}
|
|
};
|
|
this.remove = function(func) {
|
|
var id = String(func);
|
|
if (listeners[id]) {
|
|
listeners[id] = null;
|
|
delete listeners[id];
|
|
this.count--;
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
this.removeAll = function() {
|
|
for (var id in listeners) {
|
|
if (listeners.hasOwnProperty(id)) this.remove(listeners[id]);
|
|
}
|
|
};
|
|
this.broadcast = function(args) {
|
|
var localListners = {}
|
|
for (var id in listeners) localListners[id] = listeners[id]
|
|
for (var id in localListners) {
|
|
if (localListners.hasOwnProperty(id)) localListners[id].apply({}, args);
|
|
}
|
|
};
|
|
this.toString = function() {
|
|
var out = [event, ':'];
|
|
for (var id in listeners) {
|
|
if (listeners.hasOwnProperty(id)) out.push('|', id, '|');
|
|
}
|
|
return out.join('');
|
|
};
|
|
};
|
|
var broadcastEvent = function() {
|
|
var args = new Array(arguments.length);
|
|
var l = arguments.length;
|
|
for (var i = 0; i < l; i++) args[i] = arguments[i];
|
|
var event = args.shift();
|
|
mraidbridge.log("listeners:" + JSON.stringify(listeners) + "event:" + JSON.stringify(event))
|
|
if (listeners[event]) {
|
|
mraidbridge.log("broadcastEvent" + event + " with args -" + JSON.stringify(args))
|
|
listeners[event].broadcast(args);
|
|
} else {
|
|
mraidbridge.log("broadcastEvent not sent")
|
|
}
|
|
};
|
|
var contains = function(value, array) {
|
|
for (var i in array) {
|
|
if (array[i] === value) return true;
|
|
}
|
|
return false;
|
|
};
|
|
var clone = function(obj) {
|
|
if (obj === null) return null;
|
|
var f = function() {};
|
|
f.prototype = obj;
|
|
return new f();
|
|
};
|
|
var stringify = function(obj) {
|
|
if (typeof obj === 'object') {
|
|
var out = [];
|
|
if (obj.push) {
|
|
// Array.
|
|
for (var p in obj) out.push(obj[p]);
|
|
return '[' + out.join(',') + ']';
|
|
} else {
|
|
// Other object.
|
|
for (var p in obj) out.push("'" + p + "': " + obj[p]);
|
|
return '{' + out.join(',') + '}';
|
|
}
|
|
} else return String(obj);
|
|
};
|
|
// Functions that will be invoked by the native SDK whenever a 'change' event occurs.
|
|
var changeHandlers = {
|
|
state: function(val) {
|
|
if (state === STATES.LOADING) {
|
|
broadcastEvent(EVENTS.INFO, 'Native SDK initialized.');
|
|
}
|
|
state = val;
|
|
broadcastEvent(EVENTS.INFO, 'Set state to ' + stringify(val));
|
|
broadcastEvent(EVENTS.STATECHANGE, state);
|
|
},
|
|
viewable: function(val) {
|
|
isViewable = val;
|
|
broadcastEvent(EVENTS.INFO, 'Set isViewable to ' + stringify(val));
|
|
broadcastEvent(EVENTS.VIEWABLECHANGE, isViewable);
|
|
},
|
|
placementType: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Set placementType to ' + stringify(val));
|
|
placementType = val;
|
|
},
|
|
adSize: function(val) {
|
|
mraidbridge.log("adSize change to " + JSON.stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) adSize[key] = val[key];
|
|
}
|
|
if (!hasSetCustomSize) {
|
|
mraidbridge.log("sizeChange broadcast with" + JSON.stringify(adSize));
|
|
broadcastEvent(EVENTS.SIZECHANGE, adSize['width'], adSize['height']);
|
|
}
|
|
},
|
|
screenSize: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Set screenSize to ' + stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) screenSize[key] = val[key];
|
|
}
|
|
if (!hasSetCustomSize) {
|
|
expandProperties['width'] = screenSize['width'];
|
|
expandProperties['height'] = screenSize['height'];
|
|
}
|
|
},
|
|
maxSize: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Set maxSize to ' + stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) maxSize[key] = val[key];
|
|
}
|
|
},
|
|
currentPosition: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Set currentPosition to ' + stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) currentPosition[key] = val[key];
|
|
}
|
|
|
|
broadcastEvent(EVENTS.SIZECHANGE, val.width, val.height);
|
|
},
|
|
expandProperties: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Merging expandProperties with ' + stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) expandProperties[key] = val[key];
|
|
}
|
|
},
|
|
resizeProperties: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Merging resizeProperties with ' + stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) resizeProperties[key] = val[key];
|
|
}
|
|
},
|
|
orientationProperties: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Merging orientationProperties with ' + stringify(val));
|
|
for (var key in val) {
|
|
if (val.hasOwnProperty(key)) orientationProperties[key] = val[key];
|
|
}
|
|
},
|
|
supports: function(val) {
|
|
broadcastEvent(EVENTS.INFO, 'Set supports to ' + stringify(val));
|
|
supports = val;
|
|
}
|
|
};
|
|
var validate = function(obj, validators, action, merge) {
|
|
if (!merge) {
|
|
// Check to see if any required properties are missing.
|
|
if (obj === null) {
|
|
broadcastEvent(EVENTS.ERROR, 'Required object not provided.', action);
|
|
return false;
|
|
} else {
|
|
for (var i in validators) {
|
|
if (validators.hasOwnProperty(i) && obj[i] === undefined) {
|
|
broadcastEvent(EVENTS.ERROR, 'Object is missing required property: ' + i + '.', action);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (var prop in obj) {
|
|
var validator = validators[prop];
|
|
var value = obj[prop];
|
|
if (validator && !validator(value)) {
|
|
// Failed validation.
|
|
broadcastEvent(EVENTS.ERROR, 'Value of property ' + prop + ' is invalid.',
|
|
action);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
var expandPropertyValidators = {
|
|
width: function(v) { return !isNaN(v) && v >= 0; },
|
|
height: function(v) { return !isNaN(v) && v >= 0; },
|
|
useCustomClose: function(v) { return (typeof v === 'boolean'); },
|
|
lockOrientation: function(v) { return (typeof v === 'boolean'); }
|
|
};
|
|
var resizePropertyValidators = {
|
|
width: function(v) { return !isNaN(v) && v >= 0; },
|
|
height: function(v) { return !isNaN(v) && v >= 0; },
|
|
offsetX: function(v) { return !isNaN(v); },
|
|
offsetY: function(v) { return !isNaN(v); },
|
|
allowOffscreen: function(v) { return (typeof v === 'boolean'); }
|
|
};
|
|
var orientationPropertyValidators = {
|
|
allowOrientationChange: function(v) { return (typeof v === 'boolean'); },
|
|
forceOrientation: function(v) { return !isNaN(v)}
|
|
};
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
bridge.addEventListener('change', function(properties) {
|
|
for (var p in properties) {
|
|
if (properties.hasOwnProperty(p)) {
|
|
var handler = changeHandlers[p];
|
|
handler(properties[p]);
|
|
}
|
|
}
|
|
});
|
|
bridge.addEventListener('error', function(message, action) {
|
|
broadcastEvent(EVENTS.ERROR, message, action);
|
|
});
|
|
bridge.addEventListener('ready', function() {
|
|
broadcastEvent(EVENTS.READY);
|
|
});
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////
|
|
mraid.addEventListener = function(event, listener) {
|
|
mraidbridge.log("addEventListener" + event)
|
|
if (!event || !listener) {
|
|
broadcastEvent(EVENTS.ERROR, 'Both event and listener are required.', 'addEventListener');
|
|
} else if (!contains(event, EVENTS)) {
|
|
broadcastEvent(EVENTS.ERROR, 'Unknown MRAID event: ' + event, 'addEventListener');
|
|
} else {
|
|
if (!listeners[event]) listeners[event] = new EventListeners(event);
|
|
listeners[event].add(listener);
|
|
}
|
|
};
|
|
mraid.close = function() {
|
|
if (state === STATES.HIDDEN) {
|
|
broadcastEvent(EVENTS.ERROR, 'Ad cannot be closed when it is already hidden.',
|
|
'close');
|
|
} else bridge.executeNativeCall('close');
|
|
};
|
|
mraid.expand = function(URL) {
|
|
if (state !== STATES.DEFAULT) {
|
|
broadcastEvent(EVENTS.ERROR, 'Ad can only be expanded from the default state.', 'expand');
|
|
} else {
|
|
var args = ['expand'];
|
|
if (mraid.getHasSetCustomClose()) {
|
|
args = args.concat(['shouldUseCustomClose', expandProperties.useCustomClose ? 'true' : 'false']);
|
|
}
|
|
if (mraid.getHasSetCustomSize()) {
|
|
if (expandProperties.width >= 0 && expandProperties.height >= 0) {
|
|
args = args.concat(['w', expandProperties.width, 'h', expandProperties.height]);
|
|
}
|
|
}
|
|
if (typeof expandProperties.lockOrientation !== 'undefined') {
|
|
args = args.concat(['lockOrientation', expandProperties.lockOrientation]);
|
|
}
|
|
if (URL) {
|
|
args = args.concat(['url', URL]);
|
|
}
|
|
bridge.executeNativeCall.apply(this, args);
|
|
}
|
|
};
|
|
mraid.getHasSetCustomClose = function() {
|
|
mraidbridge.log("mraidbridge: getHasSetCustomClose");
|
|
return hasSetCustomClose;
|
|
};
|
|
mraid.getHasSetCustomSize = function() {
|
|
mraidbridge.log("mraidbridge: getHasSetCustomSize");
|
|
return hasSetCustomSize;
|
|
};
|
|
mraid.getExpandProperties = function() {
|
|
mraidbridge.log("mraidbridge: getExpandProperties");
|
|
var properties = {
|
|
width: expandProperties.width,
|
|
height: expandProperties.height,
|
|
useCustomClose: expandProperties.useCustomClose,
|
|
isModal: expandProperties.isModal
|
|
};
|
|
return properties;
|
|
};
|
|
mraid.getPlacementType = function() {
|
|
mraidbridge.log("mraidbridge: getPlacementType");
|
|
return placementType;
|
|
};
|
|
mraid.getState = function() {
|
|
mraidbridge.log("mraidbridge: getState - " + state);
|
|
return state;
|
|
};
|
|
mraid.getVersion = function() {
|
|
return mraid.VERSION;
|
|
};
|
|
mraid.isViewable = function() {
|
|
mraidbridge.log("mraidbridge: isViewable returns " + isViewable);
|
|
return isViewable;
|
|
};
|
|
mraid.open = function(URL) {
|
|
if (!URL) broadcastEvent(EVENTS.ERROR, 'URL is required.', 'open');
|
|
else bridge.executeNativeCall('open', 'url', URL);
|
|
};
|
|
mraid.removeEventListener = function(event, listener) {
|
|
if (!event) broadcastEvent(EVENTS.ERROR, 'Event is required.', 'removeEventListener');
|
|
else {
|
|
if (listener && (!listeners[event] || !listeners[event].remove(listener))) {
|
|
broadcastEvent(EVENTS.ERROR, 'LoadListener not currently registered for event.',
|
|
'removeEventListener');
|
|
return;
|
|
} else if (listeners[event]) listeners[event].removeAll();
|
|
if (listeners[event] && listeners[event].count === 0) {
|
|
listeners[event] = null;
|
|
delete listeners[event];
|
|
}
|
|
}
|
|
};
|
|
mraid.setExpandProperties = function(properties) {
|
|
if (validate(properties, expandPropertyValidators, 'setExpandProperties', true)) {
|
|
if (properties.hasOwnProperty('width') || properties.hasOwnProperty('height')) {
|
|
hasSetCustomSize = true;
|
|
}
|
|
if (properties.hasOwnProperty('useCustomClose')) hasSetCustomClose = true;
|
|
var desiredProperties = ['width', 'height', 'useCustomClose', 'lockOrientation'];
|
|
var length = desiredProperties.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var propname = desiredProperties[i];
|
|
if (properties.hasOwnProperty(propname)) expandProperties[propname] = properties[propname];
|
|
}
|
|
}
|
|
};
|
|
mraid.useCustomClose = function(shouldUseCustomClose) {
|
|
expandProperties.useCustomClose = shouldUseCustomClose;
|
|
hasSetCustomClose = true;
|
|
bridge.executeNativeCall('usecustomclose', 'shouldUseCustomClose', shouldUseCustomClose);
|
|
};
|
|
// MRAID 2.0 APIs ////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mraid.createCalendarEvent = function(parameters) {
|
|
CalendarEventParser.initialize(parameters);
|
|
if (CalendarEventParser.parse()) {
|
|
bridge.executeNativeCall.apply(this, CalendarEventParser.arguments);
|
|
} else {
|
|
broadcastEvent(EVENTS.ERROR, CalendarEventParser.errors[0], 'createCalendarEvent');
|
|
}
|
|
};
|
|
mraid.supports = function(feature) {
|
|
return supports[feature];
|
|
};
|
|
mraid.playVideo = function(uri) {
|
|
if (!mraid.isViewable()) {
|
|
broadcastEvent(EVENTS.ERROR, 'playVideo cannot be called until the ad is viewable', 'playVideo');
|
|
return;
|
|
}
|
|
if (!uri) {
|
|
broadcastEvent(EVENTS.ERROR, 'playVideo must be called with a valid URI', 'playVideo');
|
|
} else {
|
|
bridge.executeNativeCall.apply(this, ['playVideo', 'uri', uri]);
|
|
}
|
|
};
|
|
mraid.storePicture = function(uri) {
|
|
if (!mraid.isViewable()) {
|
|
broadcastEvent(EVENTS.ERROR, 'storePicture cannot be called until the ad is viewable', 'storePicture');
|
|
return;
|
|
}
|
|
if (!uri) {
|
|
broadcastEvent(EVENTS.ERROR, 'storePicture must be called with a valid URI', 'storePicture');
|
|
} else {
|
|
bridge.executeNativeCall.apply(this, ['storePicture', 'uri', uri]);
|
|
}
|
|
};
|
|
mraid.resize = function() {
|
|
if (state !== STATES.DEFAULT) {
|
|
broadcastEvent(EVENTS.ERROR, 'Ad can only be expanded from the default state.', 'resize');
|
|
} else {
|
|
var args = ['resize'];
|
|
if (mraid.getHasSetCreativeSize()) {
|
|
if (resizeProperties.width >= 0 && resizeProperties.height >= 0) {
|
|
args = args.concat(['w', resizeProperties.width, 'h', resizeProperties.height]);
|
|
}
|
|
}
|
|
if (mraid.getHasSetCreativeOffset()) {
|
|
args = args.concat(['offsetX', resizeProperties.offsetX, 'offsetY', resizeProperties.offsetY]);
|
|
}
|
|
if (typeof resizeProperties.allowOffscreen !== 'undefined') {
|
|
args = args.concat(['allowOffscreen', resizeProperties.allowOffscreen]);
|
|
}
|
|
if (typeof resizeProperties.customClosePosition !== 'undefined') {
|
|
args = args.concat(['customClosePosition', resizeProperties.customClosePosition]);
|
|
}
|
|
bridge.executeNativeCall.apply(this, args);
|
|
}
|
|
};
|
|
mraid.getResizeProperties = function() {
|
|
|
|
var properties = {
|
|
width: resizeProperties.width,
|
|
height: resizeProperties.height,
|
|
customClosePosition: resizeProperties.customClosePosition,
|
|
offsetX: resizeProperties.offsetX,
|
|
offsetY: resizeProperties.offsetY,
|
|
allowOffscreen: resizeProperties.allowOffscreen
|
|
};
|
|
return properties;
|
|
};
|
|
mraid.setResizeProperties = function(properties) {
|
|
if (validate(properties, resizePropertyValidators, 'setResizeProperties', true)) {
|
|
if (properties.hasOwnProperty('width') || properties.hasOwnProperty('height')) {
|
|
hasSetCreativeSize = true;
|
|
}
|
|
if (properties.hasOwnProperty('offsetX') || properties.hasOwnProperty('offsetY')) {
|
|
hasSetCreativeOffset = true;
|
|
}
|
|
if (properties.hasOwnProperty('useCustomClose')) hasSetCustomClose = true;
|
|
var desiredProperties = ['width', 'height', 'offsetX', 'offsetY', 'customClosePosition', 'allowOffscreen'];
|
|
var length = desiredProperties.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var propname = desiredProperties[i];
|
|
if (properties.hasOwnProperty(propname)) resizeProperties[propname] = properties[propname];
|
|
}
|
|
}
|
|
};
|
|
|
|
mraid.setOrientationProperties = function (properties) {
|
|
var args = ['setOrientationProperties'];
|
|
// if (validate(properties, orientationPropertyValidators, 'setOrientationProperties', true)) {
|
|
var desiredProperties = ['allowOrientationChange', 'forceOrientation'];
|
|
var length = desiredProperties.length;
|
|
for (var i = 0; i < length; i++) {
|
|
var propname = desiredProperties[i];
|
|
if (properties.hasOwnProperty(propname)) orientationProperties[propname] = properties[propname];
|
|
args = args.concat([propname, orientationProperties[propname]]);
|
|
}
|
|
// }
|
|
|
|
bridge.executeNativeCall.apply(this, args);
|
|
};
|
|
|
|
mraid.getHasSetCreativeSize = function() {
|
|
return hasSetCreativeSize;
|
|
};
|
|
|
|
mraid.getHasSetCreativeOffset = function() {
|
|
return hasSetCreativeOffset;
|
|
};
|
|
|
|
mraid.getOrientationProperties = function () {
|
|
return clone(orientationProperties);
|
|
};
|
|
|
|
mraid.getCurrentPosition = function () {
|
|
return clone(currentPosition);
|
|
};
|
|
|
|
mraid.getDefaultPosition = function() {
|
|
return clone(mraidDefaultPosition);
|
|
};
|
|
|
|
mraid.getMaxSize = function() {
|
|
mraidbridge.log("getMaxSize" + JSON.stringify(maxSize))
|
|
return clone(maxSize);
|
|
};
|
|
|
|
mraid.getScreenSize = function() {
|
|
return clone(screenSize);
|
|
};
|
|
|
|
var CalendarEventParser = {
|
|
initialize: function(parameters) {
|
|
this.parameters = parameters;
|
|
this.errors = [];
|
|
this.arguments = ['createCalendarEvent'];
|
|
},
|
|
parse: function() {
|
|
if (!this.parameters) {
|
|
this.errors.push('The object passed to createCalendarEvent cannot be null.');
|
|
} else {
|
|
this.parseDescription();
|
|
this.parseLocation();
|
|
this.parseSummary();
|
|
this.parseStartAndEndDates();
|
|
this.parseReminder();
|
|
this.parseRecurrence();
|
|
this.parseTransparency();
|
|
}
|
|
var errorCount = this.errors.length;
|
|
if (errorCount) {
|
|
this.arguments.length = 0;
|
|
}
|
|
return (errorCount === 0);
|
|
},
|
|
parseDescription: function() {
|
|
this._processStringValue('description');
|
|
},
|
|
parseLocation: function() {
|
|
this._processStringValue('location');
|
|
},
|
|
parseSummary: function() {
|
|
this._processStringValue('summary');
|
|
},
|
|
parseStartAndEndDates: function() {
|
|
this._processDateValue('start');
|
|
this._processDateValue('end');
|
|
},
|
|
parseReminder: function() {
|
|
var reminder = this._getParameter('reminder');
|
|
if (!reminder) {
|
|
return;
|
|
}
|
|
if (reminder < 0) {
|
|
this.arguments.push('relativeReminder');
|
|
this.arguments.push(parseInt(reminder) / 1000);
|
|
} else {
|
|
this.arguments.push('absoluteReminder');
|
|
this.arguments.push(reminder);
|
|
}
|
|
},
|
|
parseRecurrence: function() {
|
|
var recurrenceDict = this._getParameter('recurrence');
|
|
if (!recurrenceDict) {
|
|
return;
|
|
}
|
|
this.parseRecurrenceInterval(recurrenceDict);
|
|
this.parseRecurrenceFrequency(recurrenceDict);
|
|
this.parseRecurrenceEndDate(recurrenceDict);
|
|
this.parseRecurrenceArrayValue(recurrenceDict, 'daysInWeek');
|
|
this.parseRecurrenceArrayValue(recurrenceDict, 'daysInMonth');
|
|
this.parseRecurrenceArrayValue(recurrenceDict, 'daysInYear');
|
|
this.parseRecurrenceArrayValue(recurrenceDict, 'monthsInYear');
|
|
},
|
|
parseTransparency: function() {
|
|
var validValues = ['opaque', 'transparent'];
|
|
if (this.parameters.hasOwnProperty('transparency')) {
|
|
var transparency = this.parameters['transparency'];
|
|
if (contains(transparency, validValues)) {
|
|
this.arguments.push('transparency');
|
|
this.arguments.push(transparency);
|
|
} else {
|
|
this.errors.push('transparency must be opaque or transparent');
|
|
}
|
|
}
|
|
},
|
|
parseRecurrenceArrayValue: function(recurrenceDict, kind) {
|
|
if (recurrenceDict.hasOwnProperty(kind)) {
|
|
var array = recurrenceDict[kind];
|
|
if (!array || !(array instanceof Array)) {
|
|
this.errors.push(kind + ' must be an array.');
|
|
} else {
|
|
var arrayStr = array.join(',');
|
|
this.arguments.push(kind);
|
|
this.arguments.push(arrayStr);
|
|
}
|
|
}
|
|
},
|
|
parseRecurrenceInterval: function(recurrenceDict) {
|
|
if (recurrenceDict.hasOwnProperty('interval')) {
|
|
var interval = recurrenceDict['interval'];
|
|
if (!interval) {
|
|
this.errors.push('Recurrence interval cannot be null.');
|
|
} else {
|
|
this.arguments.push('interval');
|
|
this.arguments.push(interval);
|
|
}
|
|
} else {
|
|
// If a recurrence rule was specified without an interval, use a default value of 1.
|
|
this.arguments.push('interval');
|
|
this.arguments.push(1);
|
|
}
|
|
},
|
|
parseRecurrenceFrequency: function(recurrenceDict) {
|
|
if (recurrenceDict.hasOwnProperty('frequency')) {
|
|
var frequency = recurrenceDict['frequency'];
|
|
var validFrequencies = ['daily', 'weekly', 'monthly', 'yearly'];
|
|
if (contains(frequency, validFrequencies)) {
|
|
this.arguments.push('frequency');
|
|
this.arguments.push(frequency);
|
|
} else {
|
|
this.errors.push("Recurrence frequency must be one of: 'daily, 'weekly', 'monthly', 'yearly'.");
|
|
}
|
|
}
|
|
},
|
|
parseRecurrenceEndDate: function(recurrenceDict) {
|
|
var expires = recurrenceDict['expires'];
|
|
if (!expires) {
|
|
return;
|
|
}
|
|
this.arguments.push('expires');
|
|
this.arguments.push(expires);
|
|
},
|
|
_getParameter: function(key) {
|
|
if (this.parameters.hasOwnProperty(key)) {
|
|
return this.parameters[key];
|
|
}
|
|
return null;
|
|
},
|
|
_processStringValue: function(kind) {
|
|
if (this.parameters.hasOwnProperty(kind)) {
|
|
var value = this.parameters[kind];
|
|
this.arguments.push(kind);
|
|
this.arguments.push(value);
|
|
}
|
|
},
|
|
_processDateValue: function(kind) {
|
|
if (this.parameters.hasOwnProperty(kind)) {
|
|
var dateString = this._getParameter(kind);
|
|
this.arguments.push(kind);
|
|
this.arguments.push(dateString);
|
|
}
|
|
}
|
|
};
|
|
}());
|
|
</script> |