Sync::Handle()

Complexity

Conditions	236
Paths	> 20000

Size

Total Lines	1004
Code Lines	535

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

<?php
	public function Handle($commandCode) {
		// Contains all requested folders (containers)
		$sc = new SyncCollections();
		$status = SYNC_STATUS_SUCCESS;
		$wbxmlproblem = false;
		$emptysync = false;
		$this->singleFolder = true;
		$this->multiFolderInfo = [];
		$this->globallyExportedItems = 0;

		// check if the hierarchySync was fully completed
		if (USE_PARTIAL_FOLDERSYNC) {
			if (self::$deviceManager->GetFolderSyncComplete() === false) {
				SLog::Write(LOGLEVEL_INFO, "Request->HandleSync(): Sync request aborted, as exporting of folders has not yet completed");
				self::$topCollector->AnnounceInformation("Aborted due incomplete folder sync", true);
				$status = SYNC_STATUS_FOLDERHIERARCHYCHANGED;
			}
			else {
				SLog::Write(LOGLEVEL_INFO, "Request->HandleSync(): FolderSync marked as complete");
			}
		}

		// Start Synchronize
		if (self::$decoder->getElementStartTag(SYNC_SYNCHRONIZE)) {
			// AS 1.0 sends version information in WBXML
			if (self::$decoder->getElementStartTag(SYNC_VERSION)) {
				$sync_version = self::$decoder->getElementContent();
				SLog::Write(LOGLEVEL_DEBUG, sprintf("WBXML sync version: '%s'", $sync_version));
				if (!self::$decoder->getElementEndTag()) {
					return false;
				}
			}

			// Syncing specified folders
			// Android still sends heartbeat sync even if all syncfolders are disabled.
			// Check if Folders tag is empty (<Folders/>) and only sync if there are
			// some folders in the request.
			$startTag = self::$decoder->getElementStartTag(SYNC_FOLDERS);
			if (isset($startTag[EN_FLAGS]) && $startTag[EN_FLAGS]) {
				while (self::$decoder->getElementStartTag(SYNC_FOLDER)) {
					$actiondata = [];
					$actiondata["requested"] = true;
					$actiondata["clientids"] = [];
					$actiondata["modifyids"] = [];
					$actiondata["removeids"] = [];
					$actiondata["fetchids"] = [];
					$actiondata["statusids"] = [];

					// read class, synckey and folderid without SyncParameters Object for now
					$class = $synckey = $folderid = false;

The assignment to $synckey is dead and can be removed.

					// if there are already collections in SyncCollections, this is min. the second folder
					if ($sc->HasCollections()) {
						$this->singleFolder = false;
					}

					// for AS versions < 2.5
					if (self::$decoder->getElementStartTag(SYNC_FOLDERTYPE)) {
						$class = self::$decoder->getElementContent();
						SLog::Write(LOGLEVEL_DEBUG, sprintf("Sync folder: '%s'", $class));

						if (!self::$decoder->getElementEndTag()) {
							return false;
						}
					}

					// SyncKey
					if (self::$decoder->getElementStartTag(SYNC_SYNCKEY)) {
						$synckey = "0";
						if (($synckey = self::$decoder->getElementContent()) !== false) {
							if (!self::$decoder->getElementEndTag()) {
								return false;
							}
						}
					}
					else {
						return false;
					}

					// FolderId
					if (self::$decoder->getElementStartTag(SYNC_FOLDERID)) {
						$folderid = self::$decoder->getElementContent();

						if (!self::$decoder->getElementEndTag()) {
							return false;
						}
					}

					// compatibility mode AS 1.0 - get folderid which was sent during GetHierarchy()
					if (!$folderid && $class) {
						$folderid = self::$deviceManager->GetFolderIdFromCacheByClass($class);
					}

					// folderid HAS TO BE known by now, so we retrieve the correct SyncParameters object for an update
					try {
						$spa = self::$deviceManager->GetStateManager()->GetSynchedFolderState($folderid);

						// TODO remove resync of folders
						// this forces a resync of all states
						if (!$spa instanceof SyncParameters) {
							throw new StateInvalidException("Saved state are not of type SyncParameters");
						}

						// new/resync requested
						if ($synckey == "0") {
							$spa->RemoveSyncKey();
							$spa->DelFolderStat();

The method DelFolderStat() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

							$spa->SetMoveState(false);

The method SetMoveState() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						}
						elseif ($synckey !== false) {
							if ($synckey !== $spa->GetSyncKey() && $synckey !== $spa->GetNewSyncKey()) {
								SLog::Write(LOGLEVEL_DEBUG, "HandleSync(): Synckey does not match latest saved for this folder or there is a move state, removing folderstat to force Exporter setup");
								$spa->DelFolderStat();
							}
							$spa->SetSyncKey($synckey);
						}
					}
					catch (StateInvalidException $stie) {
						$spa = new SyncParameters();
						$status = SYNC_STATUS_INVALIDSYNCKEY;
						self::$topCollector->AnnounceInformation("State invalid - Resync folder", $this->singleFolder);
						self::$deviceManager->ForceFolderResync($folderid);
						$this->saveMultiFolderInfo("exception", "StateInvalidException");
					}

					// update folderid.. this might be a new object
					$spa->SetFolderId($folderid);

The method SetFolderId() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

					$spa->SetBackendFolderId(self::$deviceManager->GetBackendIdForFolderId($folderid));

The method SetBackendFolderId() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

					if ($class !== false) {
						$spa->SetContentClass($class);

The method SetContentClass() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

					}

					// Get class for as versions >= 12.0
					if (!$spa->HasContentClass()) {

The method HasContentClass() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						try {
							$spa->SetContentClass(self::$deviceManager->GetFolderClassFromCacheByID($spa->GetFolderId()));

The method GetFolderId() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

							SLog::Write(LOGLEVEL_DEBUG, sprintf("GetFolderClassFromCacheByID from Device Manager: '%s' for id:'%s'", $spa->GetContentClass(), $spa->GetFolderId()));

The method GetContentClass() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						}
						catch (NoHierarchyCacheAvailableException $nhca) {
							$status = SYNC_STATUS_FOLDERHIERARCHYCHANGED;
							self::$deviceManager->ForceFullResync();
						}
					}

					// done basic SPA initialization/loading -> add to SyncCollection
					$sc->AddCollection($spa);
					$sc->AddParameter($spa, "requested", true);

					if ($spa->HasContentClass()) {
						self::$topCollector->AnnounceInformation(sprintf("%s request", $spa->GetContentClass()), $this->singleFolder);
					}
					else {
						SLog::Write(LOGLEVEL_WARN, "Not possible to determine class of request. Request did not contain class and apparently there is an issue with the HierarchyCache.");
					}

					// SUPPORTED properties
					if (($se = self::$decoder->getElementStartTag(SYNC_SUPPORTED)) !== false) {
						// LG phones send an empty supported tag, so only read the contents if available here
						// if <Supported/> is received, it's as no supported fields would have been sent at all.
						// unsure if this is the correct approach, or if in this case some default list should be used
						if ($se[EN_FLAGS] & EN_FLAGS_CONTENT) {
							$supfields = [];
							WBXMLDecoder::ResetInWhile("syncSupported");
							while (WBXMLDecoder::InWhile("syncSupported")) {
								$el = self::$decoder->getElement();

								if ($el[EN_TYPE] == EN_TYPE_ENDTAG) {
									break;
								}

								$supfields[] = $el[EN_TAG];
							}
							self::$deviceManager->SetSupportedFields($spa->GetFolderId(), $supfields);
						}
					}

					// Deletes as moves can be an empty tag as well as have value
					if (self::$decoder->getElementStartTag(SYNC_DELETESASMOVES)) {
						$spa->SetDeletesAsMoves(true);

The method SetDeletesAsMoves() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						if (($dam = self::$decoder->getElementContent()) !== false) {
							$spa->SetDeletesAsMoves((bool) $dam);
							if (!self::$decoder->getElementEndTag()) {
								return false;
							}
						}
					}

					// Get changes can be an empty tag as well as have value
					// code block partly contributed by dw2412
					if ($starttag = self::$decoder->getElementStartTag(SYNC_GETCHANGES)) {
						$sc->AddParameter($spa, "getchanges", true);
						if (($gc = self::$decoder->getElementContent()) !== false) {
							$sc->AddParameter($spa, "getchanges", $gc);
						}
						// read the endtag if SYNC_GETCHANGES wasn't an empty tag
						if ($starttag[EN_FLAGS] & EN_FLAGS_CONTENT) {
							if (!self::$decoder->getElementEndTag()) {
								return false;
							}
						}
					}

					if (self::$decoder->getElementStartTag(SYNC_WINDOWSIZE)) {
						$ws = self::$decoder->getElementContent();
						// normalize windowsize
						if ($ws == 0 || $ws > WINDOW_SIZE_MAX) {
							$ws = WINDOW_SIZE_MAX;
						}

						$spa->SetWindowSize($ws);

The method SetWindowSize() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						// also announce the currently requested window size to the DeviceManager
						self::$deviceManager->SetWindowSize($spa->GetFolderId(), $spa->GetWindowSize());

The method GetWindowSize() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						if (!self::$decoder->getElementEndTag()) {
							return false;
						}
					}

					// conversation mode requested
					if (self::$decoder->getElementStartTag(SYNC_CONVERSATIONMODE)) {
						$spa->SetConversationMode(true);

The method SetConversationMode() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						if (($conversationmode = self::$decoder->getElementContent()) !== false) {
							$spa->SetConversationMode((bool) $conversationmode);
							if (!self::$decoder->getElementEndTag()) {
								return false;
							}
						}
					}

					// Do not truncate by default
					$spa->SetTruncation(SYNC_TRUNCATION_ALL);

The method SetTruncation() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

					// use default conflict handling if not specified by the mobile
					$spa->SetConflict(SYNC_CONFLICT_DEFAULT);

The method SetConflict() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

					// save the current filtertype because it might have been changed on the mobile
					$currentFilterType = $spa->GetFilterType();

The method GetFilterType() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

					while (self::$decoder->getElementStartTag(SYNC_OPTIONS)) {
						$firstOption = true;
						WBXMLDecoder::ResetInWhile("syncOptions");
						while (WBXMLDecoder::InWhile("syncOptions")) {
							// foldertype definition
							if (self::$decoder->getElementStartTag(SYNC_FOLDERTYPE)) {
								$foldertype = self::$decoder->getElementContent();
								SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): specified options block with foldertype '%s'", $foldertype));

								// switch the foldertype for the next options
								$spa->UseCPO($foldertype);

								// save the current filtertype because it might have been changed on the mobile
								$currentFilterType = $spa->GetFilterType();

								// set to synchronize all changes. The mobile could overwrite this value
								$spa->SetFilterType(SYNC_FILTERTYPE_ALL);

The method SetFilterType() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}
							// if no foldertype is defined, use default cpo
							elseif ($firstOption) {
								$spa->UseCPO();
								// save the current filtertype because it might have been changed on the mobile
								$currentFilterType = $spa->GetFilterType();
								// set to synchronize all changes. The mobile could overwrite this value
								$spa->SetFilterType(SYNC_FILTERTYPE_ALL);
							}
							$firstOption = false;

							if (self::$decoder->getElementStartTag(SYNC_FILTERTYPE)) {
								$spa->SetFilterType(self::$decoder->getElementContent());
								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}
							if (self::$decoder->getElementStartTag(SYNC_TRUNCATION)) {
								$spa->SetTruncation(self::$decoder->getElementContent());
								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}
							if (self::$decoder->getElementStartTag(SYNC_RTFTRUNCATION)) {
								$spa->SetRTFTruncation(self::$decoder->getElementContent());

The method SetRTFTruncation() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							if (self::$decoder->getElementStartTag(SYNC_MIMESUPPORT)) {
								$spa->SetMimeSupport(self::$decoder->getElementContent());

The method SetMimeSupport() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							if (self::$decoder->getElementStartTag(SYNC_MIMETRUNCATION)) {
								$spa->SetMimeTruncation(self::$decoder->getElementContent());

The method SetMimeTruncation() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							if (self::$decoder->getElementStartTag(SYNC_CONFLICT)) {
								$spa->SetConflict(self::$decoder->getElementContent());
								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							while (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_BODYPREFERENCE)) {
								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_TYPE)) {
									$bptype = self::$decoder->getElementContent();
									$spa->BodyPreference($bptype);

The method BodyPreference() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_TRUNCATIONSIZE)) {
									$spa->BodyPreference($bptype)->SetTruncationSize(self::$decoder->getElementContent());

The variable $bptype does not seem to be defined for all execution paths leading up to this point.

									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_ALLORNONE)) {
									$spa->BodyPreference($bptype)->SetAllOrNone(self::$decoder->getElementContent());
									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_PREVIEW)) {
									$spa->BodyPreference($bptype)->SetPreview(self::$decoder->getElementContent());
									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_BODYPARTPREFERENCE)) {
								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_TYPE)) {
									$bpptype = self::$decoder->getElementContent();
									$spa->BodyPartPreference($bpptype);

The method BodyPartPreference() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_TRUNCATIONSIZE)) {
									$spa->BodyPartPreference($bpptype)->SetTruncationSize(self::$decoder->getElementContent());

The variable $bpptype does not seem to be defined for all execution paths leading up to this point.

									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_ALLORNONE)) {
									$spa->BodyPartPreference($bpptype)->SetAllOrNone(self::$decoder->getElementContent());
									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_PREVIEW)) {
									$spa->BodyPartPreference($bpptype)->SetPreview(self::$decoder->getElementContent());
									if (!self::$decoder->getElementEndTag()) {
										return false;
									}
								}

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							if (self::$decoder->getElementStartTag(SYNC_RIGHTSMANAGEMENT_SUPPORT)) {
								$spa->SetRmSupport(self::$decoder->getElementContent());

The method SetRmSupport() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}

							$e = self::$decoder->peek();
							if ($e[EN_TYPE] == EN_TYPE_ENDTAG) {
								self::$decoder->getElementEndTag();

								break;
							}
						}
					}

					// limit items to be synchronized to the mobiles if configured
					$maxAllowed = self::$deviceManager->GetFilterType($spa->GetFolderId(), $spa->GetBackendFolderId());
					if ($maxAllowed > SYNC_FILTERTYPE_ALL &&
						(!$spa->HasFilterType() || $spa->GetFilterType() == SYNC_FILTERTYPE_ALL || $spa->GetFilterType() > $maxAllowed)) {

The method HasFilterType() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

						SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): FilterType applied globally or specifically, using value: %s", $maxAllowed));
						$spa->SetFilterType($maxAllowed);
					}

					if ($currentFilterType != $spa->GetFilterType()) {
						SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): FilterType has changed (old: '%s', new: '%s'), removing folderstat to force Exporter setup", $currentFilterType, $spa->GetFilterType()));
						$spa->DelFolderStat();
					}

					// Check if the hierarchycache is available. If not, trigger a HierarchySync
					if (self::$deviceManager->IsHierarchySyncRequired()) {
						$status = SYNC_STATUS_FOLDERHIERARCHYCHANGED;
						SLog::Write(LOGLEVEL_DEBUG, "HierarchyCache is also not available. Triggering HierarchySync to device");
					}

					// AS16: Check if this is a DRAFTS folder - if so, disable FilterType
					if (Request::GetProtocolVersion() >= 16.0 && self::$deviceManager->GetFolderTypeFromCacheById($spa->GetFolderId()) == SYNC_FOLDER_TYPE_DRAFTS) {
						$spa->SetFilterType(SYNC_FILTERTYPE_DISABLE);
						SLog::Write(LOGLEVEL_DEBUG, "HandleSync(): FilterType has been disabled as this is a DRAFTS folder.");
					}

					if (($el = self::$decoder->getElementStartTag(SYNC_PERFORM)) && ($el[EN_FLAGS] & EN_FLAGS_CONTENT)) {
						// We can not proceed here as the content class is unknown
						if ($status != SYNC_STATUS_SUCCESS) {
							SLog::Write(LOGLEVEL_WARN, "Ignoring all incoming actions as global status indicates problem.");
							$wbxmlproblem = true;

							break;
						}

						$performaction = true;

						// unset the importer
						$this->importer = false;

						$nchanges = 0;
						WBXMLDecoder::ResetInWhile("syncActions");
						while (WBXMLDecoder::InWhile("syncActions")) {
							// ADD, MODIFY, REMOVE or FETCH
							$element = self::$decoder->getElement();

							if ($element[EN_TYPE] != EN_TYPE_STARTTAG) {
								self::$decoder->ungetElement($element);

								break;
							}

							if ($status == SYNC_STATUS_SUCCESS) {
								++$nchanges;
							}

							// Foldertype sent when syncing SMS
							if (self::$decoder->getElementStartTag(SYNC_FOLDERTYPE)) {
								$foldertype = self::$decoder->getElementContent();
								SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): incoming data with foldertype '%s'", $foldertype));

								if (!self::$decoder->getElementEndTag()) {
									return false;
								}
							}
							else {
								$foldertype = false;
							}

							$serverid = false;
							if (self::$decoder->getElementStartTag(SYNC_SERVERENTRYID)) {
								if (($serverid = self::$decoder->getElementContent()) !== false) {
									if (!self::$decoder->getElementEndTag()) { // end serverid
										return false;
									}
								}
							}
							// get the instanceId if available
							$instanceid = false;
							if (self::$decoder->getElementStartTag(SYNC_AIRSYNCBASE_INSTANCEID)) {
								if (($instanceid = self::$decoder->getElementContent()) !== false) {
									if (!self::$decoder->getElementEndTag()) { // end instanceid
										return false;
									}
								}
							}

							if (self::$decoder->getElementStartTag(SYNC_CLIENTENTRYID)) {
								$clientid = self::$decoder->getElementContent();

								if (!self::$decoder->getElementEndTag()) { // end clientid
									return false;
								}
							}
							else {
								$clientid = false;
							}

							// Get the SyncMessage if sent
							if (($el = self::$decoder->getElementStartTag(SYNC_DATA)) && ($el[EN_FLAGS] & EN_FLAGS_CONTENT)) {
								$message = GSync::getSyncObjectFromFolderClass($spa->GetContentClass());
								$message->Decode(self::$decoder);

								// set Ghosted fields
								$message->emptySupported(self::$deviceManager->GetSupportedFields($spa->GetFolderId()));

								if (!self::$decoder->getElementEndTag()) { // end applicationdata
									return false;
								}
							}
							else {
								$message = false;
							}

							// InstanceID sent: do action to a recurrency exception
							if ($instanceid) {
								// for delete actions we don't have an ASObject
								if (!$message) {
									$message = GSync::getSyncObjectFromFolderClass($spa->GetContentClass());
									$message->Decode(self::$decoder);
								}
								$message->instanceid = $instanceid;

The property instanceid does not exist on string.

								if ($element[EN_TAG] == SYNC_REMOVE) {
									$message->instanceiddelete = true;

The property instanceiddelete does not exist on string.

									$element[EN_TAG] = SYNC_MODIFY;
								}
							}

							switch ($element[EN_TAG]) {
								case SYNC_FETCH:
									array_push($actiondata["fetchids"], $serverid);
									break;

								default:
									// get the importer
									if ($this->importer === false) {
										$status = $this->getImporter($sc, $spa, $actiondata);
									}

									if ($status == SYNC_STATUS_SUCCESS) {
										$this->importMessage($spa, $actiondata, $element[EN_TAG], $message, $clientid, $serverid, $foldertype, $nchanges);

$message of type false|string is incompatible with the type SyncObject expected by parameter $message of Sync::importMessage().

									}
									else {
										SLog::Write(LOGLEVEL_WARN, "Ignored incoming change, global status indicates problem.");
									}
									break;
							}

							if ($actiondata["fetchids"]) {
								self::$topCollector->AnnounceInformation(sprintf("Fetching %d", $nchanges));
							}
							else {
								self::$topCollector->AnnounceInformation(sprintf("Incoming %d", $nchanges));
							}

							if (!self::$decoder->getElementEndTag()) { // end add/change/delete/move
								return false;
							}
						}

						if ($status == SYNC_STATUS_SUCCESS && $this->importer !== false) {
							SLog::Write(LOGLEVEL_INFO, sprintf("Processed '%d' incoming changes", $nchanges));
							if (!$actiondata["fetchids"]) {
								self::$topCollector->AnnounceInformation(sprintf("%d incoming", $nchanges), $this->singleFolder);
								$this->saveMultiFolderInfo("incoming", $nchanges);
							}

							try {
								// Save the updated state, which is used for the exporter later
								$sc->AddParameter($spa, "state", $this->importer->GetState());
							}
							catch (StatusException $stex) {
								$status = $stex->getCode();
							}

							// Check if changes are requested - if not and there are no changes to be exported anyway, update folderstat!
							if (!$sc->GetParameter($spa, "getchanges") && !$sc->CountChange($spa->GetFolderId())) {
								SLog::Write(LOGLEVEL_DEBUG, "Incoming changes, no export requested: update folderstat");
								$newFolderStatAfterImport = self::$backend->GetFolderStat(GSync::GetAdditionalSyncFolderStore($spa->GetBackendFolderId()), $spa->GetBackendFolderId());
								$this->setFolderStat($spa, $newFolderStatAfterImport);
							}
						}

						if (!self::$decoder->getElementEndTag()) { // end PERFORM
							return false;
						}
					}

					// save the failsafe state
					if (!empty($actiondata["statusids"])) {
						unset($actiondata["failstate"]);
						$actiondata["failedsyncstate"] = $sc->GetParameter($spa, "state");
						self::$deviceManager->GetStateManager()->SetSyncFailState($actiondata);
					}

					// save actiondata
					$sc->AddParameter($spa, "actiondata", $actiondata);

					if (!self::$decoder->getElementEndTag()) { // end collection
						return false;
					}

					// AS14 does not send GetChanges anymore. We should do it if there were no incoming changes
					if (!isset($performaction) && !$sc->GetParameter($spa, "getchanges") && $spa->HasSyncKey()) {
						$sc->AddParameter($spa, "getchanges", true);
					}
				} // END FOLDER

				if (!$wbxmlproblem && !self::$decoder->getElementEndTag()) { // end collections
					return false;
				}
			} // end FOLDERS

			if (self::$decoder->getElementStartTag(SYNC_HEARTBEATINTERVAL)) {
				$hbinterval = self::$decoder->getElementContent();
				if (!self::$decoder->getElementEndTag()) { // SYNC_HEARTBEATINTERVAL
					return false;
				}
			}

			if (self::$decoder->getElementStartTag(SYNC_WAIT)) {
				$wait = self::$decoder->getElementContent();
				if (!self::$decoder->getElementEndTag()) { // SYNC_WAIT
					return false;
				}

				// internally the heartbeat interval and the wait time are the same
				// heartbeat is in seconds, wait in minutes
				$hbinterval = $wait * 60;
			}

			if (self::$decoder->getElementStartTag(SYNC_WINDOWSIZE)) {
				$sc->SetGlobalWindowSize(self::$decoder->getElementContent());
				SLog::Write(LOGLEVEL_DEBUG, "Sync(): Global WindowSize requested: " . $sc->GetGlobalWindowSize());
				if (!self::$decoder->getElementEndTag()) { // SYNC_WINDOWSIZE
					return false;
				}
			}

			if (self::$decoder->getElementStartTag(SYNC_PARTIAL)) {
				$partial = true;
			}
			else {
				$partial = false;
			}

			if (!$wbxmlproblem && !self::$decoder->getElementEndTag()) { // end sync
				return false;
			}
		}
		// we did not receive a SYNCHRONIZE block - assume empty sync
		else {
			$emptysync = true;
		}
		// END SYNCHRONIZE

		// check heartbeat/wait time
		if (isset($hbinterval)) {
			if ($hbinterval < 60 || $hbinterval > 3540) {

The variable $hbinterval does not seem to be defined for all execution paths leading up to this point.

				$status = SYNC_STATUS_INVALIDWAITORHBVALUE;
				SLog::Write(LOGLEVEL_WARN, sprintf("HandleSync(): Invalid heartbeat or wait value '%s'", $hbinterval));
			}
		}

		// Partial & Empty Syncs need saved data to proceed with synchronization
		if ($status == SYNC_STATUS_SUCCESS && ($emptysync === true || $partial === true)) {

The variable $partial does not seem to be defined for all execution paths leading up to this point.

			SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): Partial or Empty sync requested. Retrieving data of synchronized folders."));

			// Load all collections - do not overwrite existing (received!), load states, check permissions and only load confirmed states!
			try {
				$sc->LoadAllCollections(false, true, true, true, true);
			}
			catch (StateInvalidException $siex) {
				$status = SYNC_STATUS_INVALIDSYNCKEY;
				self::$topCollector->AnnounceInformation("StateNotFoundException", $this->singleFolder);
				$this->saveMultiFolderInfo("exception", "StateNotFoundException");
			}
			catch (StatusException $stex) {
				$status = SYNC_STATUS_FOLDERHIERARCHYCHANGED;
				self::$topCollector->AnnounceInformation(sprintf("StatusException code: %d", $status), $this->singleFolder);
				$this->saveMultiFolderInfo("exception", "StatusException");
			}

			// update a few values
			foreach ($sc as $folderid => $spa) {
				// manually set getchanges parameter for this collection if it is synchronized
				if ($spa->HasSyncKey()) {
					$actiondata = $sc->GetParameter($spa, "actiondata");
					// request changes if no other actions are executed
					if (empty($actiondata["modifyids"]) && empty($actiondata["clientids"]) && empty($actiondata["removeids"])) {
						$sc->AddParameter($spa, "getchanges", true);
					}

					// announce WindowSize to DeviceManager
					self::$deviceManager->SetWindowSize($folderid, $spa->GetWindowSize());
				}
			}
			if (!$sc->HasCollections()) {
				$status = SYNC_STATUS_SYNCREQUESTINCOMPLETE;
			}
		}
		elseif (isset($hbinterval)) {
			// load the hierarchy data - there are no permissions to verify so we just set it to false
			if (!$sc->LoadCollection(false, true, false)) {

false of type false is incompatible with the type string expected by parameter $folderid of SyncCollections::LoadCollection().

				$status = SYNC_STATUS_FOLDERHIERARCHYCHANGED;
				self::$topCollector->AnnounceInformation(sprintf("StatusException code: %d", $status), $this->singleFolder);
				$this->saveMultiFolderInfo("exception", "StatusException");
			}
		}

		// HEARTBEAT
		if ($status == SYNC_STATUS_SUCCESS && isset($hbinterval)) {
			$interval = (defined('PING_INTERVAL') && PING_INTERVAL > 0) ? PING_INTERVAL : 30;
			$sc->SetLifetime($hbinterval);

			// states are lazy loaded - we have to make sure that they are there!
			$loadstatus = SYNC_STATUS_SUCCESS;
			foreach ($sc as $folderid => $spa) {
				// some androids do heartbeat on the OUTBOX folder, with weird results
				// we do not load the state so we will never get relevant changes on the OUTBOX folder
				if (self::$deviceManager->GetFolderTypeFromCacheById($folderid) == SYNC_FOLDER_TYPE_OUTBOX) {
					SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): Heartbeat on Outbox folder not allowed"));

					continue;
				}

				$fad = [];
				// if loading the states fails, we do not enter heartbeat, but we keep $status on SYNC_STATUS_SUCCESS
				// so when the changes are exported the correct folder gets an SYNC_STATUS_INVALIDSYNCKEY
				if ($loadstatus == SYNC_STATUS_SUCCESS) {
					$loadstatus = $this->loadStates($sc, $spa, $fad);
				}
			}

			if ($loadstatus == SYNC_STATUS_SUCCESS) {
				$foundchanges = false;

				try {
					// always check for changes
					SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): Entering Heartbeat mode"));
					$foundchanges = $sc->CheckForChanges($sc->GetLifetime(), $interval);
				}
				catch (StatusException $stex) {
					if ($stex->getCode() == SyncCollections::OBSOLETE_CONNECTION) {
						$status = SYNC_COMMONSTATUS_SYNCSTATEVERSIONINVALID;
					}
					else {
						$status = SYNC_STATUS_FOLDERHIERARCHYCHANGED;
						self::$topCollector->AnnounceInformation(sprintf("StatusException code: %d", $status), $this->singleFolder);
						$this->saveMultiFolderInfo("exception", "StatusException");
					}
				}

				// update the waittime waited
				self::$waitTime = $sc->GetWaitedSeconds();

				// in case there are no changes and no other request has synchronized while we waited, we can reply with an empty response
				if (!$foundchanges && $status == SYNC_STATUS_SUCCESS) {
					// if there were changes to the SPA or CPOs we need to save this before we terminate
					// only save if the state was not modified by some other request, if so, return state invalid status
					foreach ($sc as $folderid => $spa) {
						if (self::$deviceManager->CheckHearbeatStateIntegrity($spa->GetFolderId(), $spa->GetUuid(), $spa->GetUuidCounter())) {
							$status = SYNC_COMMONSTATUS_SYNCSTATEVERSIONINVALID;
						}
						else {
							$sc->SaveCollection($spa);
						}
					}

					if ($status == SYNC_STATUS_SUCCESS) {
						SLog::Write(LOGLEVEL_DEBUG, "No changes found and no other process changed states. Replying with empty response and closing connection.");
						self::$specialHeaders = [];
						self::$specialHeaders[] = "Connection: close";

						return true;
					}
				}

				if ($foundchanges) {
					foreach ($sc->GetChangedFolderIds() as $folderid => $changecount) {
						// check if there were other sync requests for a folder during the heartbeat
						$spa = $sc->GetCollection($folderid);
						if ($changecount > 0 && $sc->WaitedForChanges() && self::$deviceManager->CheckHearbeatStateIntegrity($spa->GetFolderId(), $spa->GetUuid(), $spa->GetUuidCounter())) {

The method GetUuid() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

The method GetUuidCounter() does not exist on SyncParameters. Since you implemented __call, consider adding a @method annotation.

							SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): heartbeat: found %d changes in '%s' which was already synchronized. Heartbeat aborted!", $changecount, $folderid));
							$status = SYNC_COMMONSTATUS_SYNCSTATEVERSIONINVALID;
						}
						else {
							SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): heartbeat: found %d changes in '%s'", $changecount, $folderid));
						}
					}
				}
			}
		}

		// Start the output
		SLog::Write(LOGLEVEL_DEBUG, "HandleSync(): Start Output");

		// global status
		// SYNC_COMMONSTATUS_* start with values from 101
		if ($status != SYNC_COMMONSTATUS_SUCCESS && ($status == SYNC_STATUS_FOLDERHIERARCHYCHANGED || $status > 100)) {
			self::$deviceManager->AnnounceProcessStatus($folderid, $status);

The variable $folderid does not seem to be defined for all execution paths leading up to this point.

			$this->sendStartTags();
			self::$encoder->startTag(SYNC_STATUS);
			self::$encoder->content($status);
			self::$encoder->endTag();
			self::$encoder->endTag(); // SYNC_SYNCHRONIZE

			return true;
		}

		// Loop through requested folders
		foreach ($sc as $folderid => $spa) {
			// get actiondata
			$actiondata = $sc->GetParameter($spa, "actiondata");

			if ($status == SYNC_STATUS_SUCCESS && (!$spa->GetContentClass() || !$spa->GetFolderId())) {
				SLog::Write(LOGLEVEL_ERROR, sprintf("HandleSync(): no content class or folderid found for collection."));

				continue;
			}

			if (!$sc->GetParameter($spa, "requested")) {
				SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync(): partial sync for folder class '%s' with id '%s'", $spa->GetContentClass(), $spa->GetFolderId()));
				// reload state and initialize StateMachine correctly
				$sc->AddParameter($spa, "state", null);
				$status = $this->loadStates($sc, $spa, $actiondata);
			}

			// initialize exporter to get changecount
			$changecount = false;
			$exporter = false;
			$streamimporter = false;
			$newFolderStat = false;
			$setupExporter = true;

			// TODO we could check against $sc->GetChangedFolderIds() on heartbeat so we do not need to configure all exporter again
			if ($status == SYNC_STATUS_SUCCESS && ($sc->GetParameter($spa, "getchanges") || !$spa->HasSyncKey())) {
				// no need to run the exporter if the globalwindowsize is already full - if collection already has a synckey
				if ($sc->GetGlobalWindowSize() == $this->globallyExportedItems && $spa->HasSyncKey()) {
					SLog::Write(LOGLEVEL_DEBUG, sprintf("Sync(): no exporter setup for '%s' as GlobalWindowSize is full.", $spa->GetFolderId()));
					$setupExporter = false;
				}
				// if the maximum request timeout is reached, stop processing other collections
				if (Request::IsRequestTimeoutReached()) {
					SLog::Write(LOGLEVEL_DEBUG, sprintf("Sync(): no exporter setup for '%s' as request timeout reached, omitting output for collection.", $spa->GetFolderId()));
					$setupExporter = false;
				}

				// if max memory allocation is reached, stop processing other collections
				if (Request::IsRequestMemoryLimitReached()) {
					SLog::Write(LOGLEVEL_DEBUG, sprintf("Sync(): no exporter setup for '%s' as max memory allocatation reached, omitting output for collection.", $spa->GetFolderId()));
					$setupExporter = false;
				}

				// force exporter run if there is a saved status
				if ($setupExporter && self::$deviceManager->HasFolderSyncStatus($spa->GetFolderId())) {
					SLog::Write(LOGLEVEL_DEBUG, sprintf("Sync(): forcing exporter setup for '%s' as a sync status is saved - ignoring backend folder stats", $spa->GetFolderId()));
				}
				// compare the folder statistics if the backend supports this
				elseif ($setupExporter && self::$backend->HasFolderStats()) {
					// check if the folder stats changed -> if not, don't setup the exporter, there are no changes!
					$newFolderStat = self::$backend->GetFolderStat(GSync::GetAdditionalSyncFolderStore($spa->GetBackendFolderId()), $spa->GetBackendFolderId());
					if ($newFolderStat !== false && !$spa->IsExporterRunRequired($newFolderStat, true)) {
						$changecount = 0;
						$setupExporter = false;
					}
				}

				// Do a full Exporter setup if we can't avoid it
				if ($setupExporter) {
					// make sure the states are loaded
					$status = $this->loadStates($sc, $spa, $actiondata);

					if ($status == SYNC_STATUS_SUCCESS) {
						try {
							// if this is an additional folder the backend has to be setup correctly
							if (!self::$backend->Setup(GSync::GetAdditionalSyncFolderStore($spa->GetBackendFolderId()))) {
								throw new StatusException(sprintf("HandleSync() could not Setup() the backend for folder id %s/%s", $spa->GetFolderId(), $spa->GetBackendFolderId()), SYNC_STATUS_FOLDERHIERARCHYCHANGED);
							}

							// Use the state from the importer, as changes may have already happened
							$exporter = self::$backend->GetExporter($spa->GetBackendFolderId());

							if ($exporter === false) {
								throw new StatusException(sprintf("HandleSync() could not get an exporter for folder id %s/%s", $spa->GetFolderId(), $spa->GetBackendFolderId()), SYNC_STATUS_FOLDERHIERARCHYCHANGED);
							}
						}
						catch (StatusException $stex) {
							$status = $stex->getCode();
						}

						try {
							// Stream the messages directly to the PDA
							$streamimporter = new ImportChangesStream(self::$encoder, GSync::getSyncObjectFromFolderClass($spa->GetContentClass()));

GSync::getSyncObjectFromFolderClass($spa->GetContentClass()) of type string is incompatible with the type SyncObject expected by parameter $class of ImportChangesStream::__construct().

							if ($exporter !== false) {
								$exporter->Config($sc->GetParameter($spa, "state"));
								$exporter->ConfigContentParameters($spa->GetCPO());
								$exporter->InitializeExporter($streamimporter);

								$changecount = $exporter->GetChangeCount();
							}
						}
						catch (StatusException $stex) {
							if ($stex->getCode() === SYNC_FSSTATUS_CODEUNKNOWN && $spa->HasSyncKey()) {
								$status = SYNC_STATUS_INVALIDSYNCKEY;
							}
							else {
								$status = $stex->getCode();
							}
						}

						if (!$spa->HasSyncKey()) {
							self::$topCollector->AnnounceInformation(sprintf("Exporter registered. %d objects queued.", $changecount), $this->singleFolder);
							$this->saveMultiFolderInfo("queued", $changecount);
							// update folder status as initialized
							$spa->SetFolderSyncTotal($changecount);
							$spa->SetFolderSyncRemaining($changecount);
							if ($changecount > 0) {
								self::$deviceManager->SetFolderSyncStatus($folderid, DeviceManager::FLD_SYNC_INITIALIZED);
							}
						}
						elseif ($status != SYNC_STATUS_SUCCESS) {
							self::$topCollector->AnnounceInformation(sprintf("StatusException code: %d", $status), $this->singleFolder);
							$this->saveMultiFolderInfo("exception", "StatusException");
						}
						self::$deviceManager->AnnounceProcessStatus($spa->GetFolderId(), $status);
					}
				}
			}

			// Get a new sync key to output to the client if any changes have been send by the mobile or a new synckey is to be sent
			if (!empty($actiondata["modifyids"]) ||
				!empty($actiondata["clientids"]) ||
				!empty($actiondata["removeids"]) ||
				(!$spa->HasSyncKey() && $status == SYNC_STATUS_SUCCESS)) {
				$spa->SetNewSyncKey(self::$deviceManager->GetStateManager()->GetNewSyncKey($spa->GetSyncKey()));
			}
			// get a new synckey only if we did not reach the global limit yet
			else {
				// when reaching the global limit for changes of all collections, stop processing other collections
				if ($sc->GetGlobalWindowSize() <= $this->globallyExportedItems) {
					SLog::Write(LOGLEVEL_DEBUG, "Global WindowSize for amount of exported changes reached, omitting output for collection.");

					continue;
				}

				// get a new synckey if there are changes are we did not reach the limit yet
				if ($changecount > 0) {
					$spa->SetNewSyncKey(self::$deviceManager->GetStateManager()->GetNewSyncKey($spa->GetSyncKey()));
				}
			}

			// Fir AS 14.0+ omit output for folder, if there were no incoming or outgoing changes and no Fetch
			if (Request::GetProtocolVersion() >= 14.0 && !$spa->HasNewSyncKey() && $changecount == 0 && empty($actiondata["fetchids"]) && $status == SYNC_STATUS_SUCCESS &&
					!$spa->HasConfirmationChanged() && ($newFolderStat === false || !$spa->IsExporterRunRequired($newFolderStat))) {
				SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync: No changes found for %s folder id '%s'. Omitting output.", $spa->GetContentClass(), $spa->GetFolderId()));

				continue;
			}

			// if there are no other responses sent, we should end with a global status
			if ($status == SYNC_STATUS_FOLDERHIERARCHYCHANGED && $this->startTagsSent === false) {
				$this->sendStartTags();
				self::$encoder->startTag(SYNC_STATUS);
				self::$encoder->content($status);
				self::$encoder->endTag();
				self::$encoder->endTag(); // SYNC_SYNCHRONIZE

				return true;
			}

			// there is something to send here, sync folder to output
			$this->syncFolder($sc, $spa, $exporter, $changecount, $streamimporter, $status, $newFolderStat);

It seems like $status can also be of type status; however, parameter $status of Sync::syncFolder() does only seem to accept integer, maybe add an additional type check?

It seems like $streamimporter can also be of type false; however, parameter $streamimporter of Sync::syncFolder() does only seem to accept ImportChangesStream, maybe add an additional type check?

			// reset status for the next folder
			$status = SYNC_STATUS_SUCCESS;
		} // END foreach collection

		// SYNC_FOLDERS - only if the starttag was sent
		if ($this->startFolderTagSent) {
			self::$encoder->endTag();
		}

		// Check if there was any response - in case of an empty sync request, we shouldn't send an empty answer
		if (!$this->startTagsSent && $emptysync === true) {
			$this->sendStartTags();
			self::$encoder->startTag(SYNC_STATUS);
			self::$encoder->content(SYNC_STATUS_SYNCREQUESTINCOMPLETE);
			self::$encoder->endTag();
		}

		// SYNC_SYNCHRONIZE - only if the starttag was sent
		if ($this->startTagsSent) {
			self::$encoder->endTag();
		}

		// final top announcement for a multi-folder sync
		if ($sc->GetCollectionCount() > 1) {
			self::$topCollector->AnnounceInformation($this->getMultiFolderInfoLine($sc->GetCollectionCount()), true);
			SLog::Write(LOGLEVEL_DEBUG, sprintf("HandleSync: Processed %d folders", $sc->GetCollectionCount()));
		}

		// update the waittime waited
		self::$waitTime = $sc->GetWaitedSeconds();

		return true;
	}